This course is easier than my expectation.

Project: I checked on some old review saying the last phase of course project is tough, schedule is tight, and make sure you have teammate can do both front end and back end. In summer 2026, we do have the code of the example application used by this course (GTOnline). We just need to learn those php and html code and apply them to our own project, which is quite simple (though it is your freedom to choose what tech stack for your own application). My team of 5 just spend 1 weekend to get the whole application done, with everyone evenly contribute to the application. As for the phase 1 and phase 2 of the course project, they are very simple that I think even one person can do all of them (I guess each semester, the group project theme would be different. But at least for the one in summer 2026, it is quite simple and straight forward). The project does have tight connection to what we learn in the course, very well designed project for education purpose. Project is a full stack project, which is great.

As for course content, I am not going to comment since you can find all the info from the syllabus, the textbook, and even the lecture video is public. You can check on them and make your own judgement whether it is worth to your goal or not.

Exam: it's not hard, since you have practice exam for each exam. Some questions are tricky though and you need to pay attention to the exact word. But as long as you get the basic question correct, your final grade shouldn't be bad.

I would recommend this course and SDP for early CS career beginner. This course may be easier than SDP I think, since the coding language used in PHP and html of this course is much easier than Java, which is needed in SDP's project.

As someone who only got a minor in CS prior to this program with not a lot of exposure to different topics, I really enjoyed this class! I think that if you work with databases or have experience in this topic, you might not get much out of this class but for the complete novice, it was really interesting and honestly really helpful to learn about how basic relational databases work.

The course doesn't really have many assignments that aren't project check-ins or exams so there's a lot of freedom as to when you complete and go through content. Although, if you're not very good at self paced worked, this might not be the class for you. The lectures are super easy to understand and cover essentially all the material needed for exams. The readings basically cover the same thing with some additional information and I found them mostly easy to get through.

The exams are not hard at all! They provide you with practice exams to take before hand that are very reflective of the material on actual exams which make it easier to study for them.

The only possible downside to this class is the group project. If you don't have a great group, it could be annoying to get done. Luckily, most of my team members were responsive and made contributions to the project so it wasn't really an issue. The early stages of the group project are also really easy to get done, the bulk of the project isn't till the end so expect to spend some time there. I also think that the full-stack nature of the project is really great for those who want that experience since I didn't really have it before either.

I would not recommend taking this course, even if you're really into databases. I work at a company in the data analytics space, and very little of what was taught in this course is applicable to industry.

You mostly learn the theory and math behind relational databases. This was mildly interesting, and somewhat helpful for understanding how to optimize your database design. Also learning how indexes and other optimizations work under the hood was helpful.

There is a brief section on SQL, which is really just the bare minimum of what you should know about the language. If you've ever used SQL, you probably already know everything you would learn in the class.

There is no mention of non-relational DBs, time series DBs, or other modern DB concepts. Most of the material for this class is frozen around the 1980s or earlier.

The group project was building a full-stack app. This was good practice, but most of our time was spent on things unrelated to the database.

Maybe things have changed, but when I took this, the TAs had a very suspicious and accusative tone in all of their posts, as if they were sure students would cheat no matter what. It seemed to create a hostile environment, and I was afraid to ask questions in the discussion threads.

If I did it over, I'd skip this one, and take a more advanced DB or analytics class.

One of the most useful courses in OMS that you can take. It will take a lot of teamwork to get through the project's early stages so be prepared.

One of the TAs is great, responds within the hour to any questions you ask.

This was my first course at OMSCS, and I chose to take it despite the not-so-great reviews. I was pleasantly surprised by the experience. For context, I work as a data specialist at a small institution and come from what I would call a flawed CS education, so even though I completed a CS bachelor's degree, I consider myself much closer to a career switcher than a traditional CS student.

The class is well organized with a clear grading breakdown:

Four exams, each worth 12.5% (50% total) A three-phase final project worth approximately 35% Participation worth 15%

Course Components

Lectures: The lectures are pretty good and cover everything you need to know about database systems fundamentals: Relational Algebra and Calculus, Normalization, SQL basics, ER design, Relational Mapping, etc.. They do a good job of preparing you for the exams. There are also methodology lectures that clearly explain what's expected for each phase of the course project.

Exams: The exams were fair, though attention to detail is VERY important (I can't stress this enough). Please read each question carefully (multiple times if necessary). Practice exams are invaluable for preparation. If you can complete the practice exam without looking up the answers, you should perform well on the actual exam.

Project: This is the most variable component of the course, as your experience will depend heavily on your group. I was fortunate to have an amazing team, and everything went smoothly, making the workload quite manageable. However, I can easily see how a difficult group dynamic could make the project extremely challenging. Be proactive early in the semester to find a strong group. While you can't predict who might drop, aim to form a team with diverse skills. Ideally, someone experienced with databases (both conceptual design and SQL), someone with backend expertise, and someone with frontend skills. Yes, frontend skills. The Project is a full-stack web application.

Grading Expectations This course is generally considered an easy B but a challenging A. There appears to be no curve. I scored in the 90s on everything and earned an A (94%). If you struggle on even one exam (and the average on the final was in the 70s) an A becomes difficult to achieve. Keep this in mind before registering; I'm providing this as helpful information, not to discourage you.

Final Thoughts Overall, I think this is an excellent course. I highly recommend it if you've never taken a database class, love databases, or want to solidify your understanding of database fundamentals. However, this course may not be ideal if you're seeking advanced database topics, looking for an easy A, or prefer to avoid group projects.

This was my first OMSCS class and I found previous reviews about it to be pretty accurate. I spent 15-20 hours per week on this class and got an A. However, take this with a grain of salt as I work as a full stack SWE and was already comfortable with databases, backend, and frontend before starting the class.

To echo other reviews, I strongly recommend learning backend and frontend development before taking this class, and/or finding teammates who have this skillset. This will save you a lot of time and headache for the group project, particularly Phase 3. Luckily for my group, I'm comfortable working across the stack and was able to unblock the team on database, backend, and frontend issues, so our development went smoothly and we did very well on the project.

This is a class about databases, so I'm still confused why students are expected to know frontend development and build a fully functional full stack web app. There is zero lecture or reading material about API or frontend development, so it doesn't make sense why so much of the project grade hinges on having a functional app and UI.

Regarding the book and lectures, I actually did find much of the material to be interesting and useful. Of course, you won't use relational algebra and calculus directly in a SWE job, but it's important to develop analytical thinking and understand the concepts behind database design.

Lastly, the exams. I didn't feel that they were intentionally trying to trick students. It's just that missing or misinterpreting a single word can change the meaning of the entire question/answer. So be sure to carefully read and re-read all questions and answers before submitting. Exams 1-3 were fair. Exam 4 seemed to be intentionally difficult, possibly to bring the class average down? I scored in the 90s on exams 1-3 and all project phases, and a 60 or 70-something on exam 4.

TLDR: Grade: A Hours: 15-20 per week Difficulty: 3/5 Overall: 4/5 Tips: Learn full stack development and carefully read all exam questions

If you go into this class expecting to learn a lot of theory, you’ll probably be happy with your experience in this class. Do not take this class without having a group that has frontend/backend development experience, because this class becomes incredibly time consuming if you’re in a group with people unwilling to learn those skills. Some past reviews complain about the TAs, but I thought they were fine and I didn’t have any issues when I requested a regrade.

Expect to spend around 10 hours/week at the beginning of the class and 15-20 hours/week near the end of the class with a good group. In a group with slackers (like I experienced), expect spending 20-25 hours/week while working on part 3 of the group project if you want a passing grade.

Exams: I studied around 20-25 hours per exam, including the time spent reading the textbook. If you read the textbook and study it a little, these will probably go fine. Practice exams are way easier than the actual exam, so prepare for more theory questions and not just the calculations/methodology covered on the practice exam.

Final Exam: This exam had a C for the median/mean grade, which is the only exam where the mean was insanely low. While all of the questions were fair to ask, there was a large portion of the exam that covered the same topic that seemed like a small mention in the textbook and was not covered in the lectures or practice exam. I averaged mostly in the 90s with a few scores in the high 80s and only needed around 65% on this exam for an A (which I achieved), so it’s definitely possible to get a terrible grade on this exam and end with an A.

Group Project: First 2 parts took around 15-20 hours for my portion, and part 3 was 50 hours. Only 1 student (not including myself) helped with part 3, so I think a more reasonable group would take 20-30 hours per person for phase 3. I had people in my group do nothing for the group project and it’s unclear how much their grade was affected by team evaluations. I know that they still got the same team grade as everyone else (separate from team evaluations).

TAs: I noticed many reviews that didn’t like the TAs, and I thought they were okay. While they occasionally said stuff like “we won’t answer that”, I think they were helpful overall. Grades are usually available 2-3 weeks after the due date, so sometimes you’ll get a project grade back <1 week before the next project deadline. While frustrating, I never struggled with fixing everything in time for the next deadline.

Don't take this class. It isn't worth it. The material in this class is more theoretical than practical. The project was an enormous waste of time (learned more about containers and front-end web development than databases). The exams are inordinately tricky for the difficulty level of the content, and it makes you feel like the staff just gate-keep good grades to keep a "healthy" curve.

TA Alex and TA Peter are both snide when students attempt to ask clarifying questions about their poorly written project writeup. Despite the fact that "Task Decomposition" is an invention of the professor's, there is very little material to model your project after, and I felt frustrated by this class more often than not.

Don't take it. There are much better classes out there.

This class absolutely sucked. I got a D in it. Brought my GPA down to like 3.4. I got A's and B's on all the other classes in OMSCS. I would avoid this class and I'm doing you all a favor. Here's why:

1. I only took this class because GA Tech has a weird system where you cannot take any in-demand, high-quality classes if you are just starting out (like Machine Learning for Trading or Deep Learning). I would reckon more than half of the class consisted of people like me, left with no other choice but to take this class that resembles something in a typical computer science curriculum

2. The TA's are snarky, snappy and snoopy. They belittle and get annoyed easily, like we work for them (even though we pay them via our tuition dollars and that makes them work for us). They don't like to repeat, help or even ignore. They will come after you with snap, curt and rude responses. So unprofessional and I have no such experience in any other OMSCS class.

3. The tests are brutal and tricky, unnecessarily so given that it is a Database class and should not be technical.

4. You are required to have at least one person versed with HTML, CSS and JAVASCRIPT or you will not do well on the group project. The rest of the group who don't know these languages well will be left to wonder if they contributed enough or how much they could do without doing anything.

5. If you want to learn CRUD operations, SQL language basics, or something similar then I suggest you watch Youtube or go on Coursera for a set of lessons. Much better and more focused on those tasks than this class.

6. Feeding off of the previous point, this class is not so much about SQL as much as building useless diagrams to conceptualize the database-building process. Most of us will never need to build databases from scratch so not sure if the diagrams are of any use other than troubleshoot database problems.

7. They release grades 3+ weeks after the due dates, so you never know if you are doing well (>=B-) or doing poorly (<B). You cannot make a decision whether to drop class or not without full information.

These 7 points should be enough to dissuade you from even thinking about hitting that "Register" button on OSCAR.

If you are left unpersuaded, let me reiterate: I received 7 A's and B's in OMSCS. This is the only class where I received a D.

I thought I was getting a B, but boy they don't release grades until weeks after due dates (so you never know where you are and don't have time to drop out).

Background: This was my first OMSCS class. My undergraduate degree is not in computer science and I had not taken a database class before. The syllabus and course description give an accurate view of what the class covers. If you have had an undergraduate database class this might not be a good fit for you.

Overall, I thought this was a good class. The material was interesting. The lectures were informative and useful. The TAs were very active in Piazza, often answering within minutes of a question being posted and the class was well run and organized. Weekly offices hours were held at time that was convenient for me, 7pm eastern time, but were not required and were recorded if you were not able to attend the live meeting. Because most people choose not to attend the live office hour session it was almost like having the instructor and TA available for you personally. The exams were fair and a good representation of what was covered in class. However, I did feel that the actual exams were more difficult than the practice exams that were made available.

There is a team project with all the pluses and minus that entails. I was lucky and had a good team were everybody contributed and got their work done on time. Because people can drop the class after teams are assigned, it was possible for teams to shrink or be reassigned. The project specification is clear from the beginning on what is required and expected.

I had a great experience as my first OMSCS class and feel like I learned a lot.

Exams are awful. No amount of prep will help because lectures suck and book sucks. Sometimes the two even contradict each other.

The professors and TAs are extremely condescending and do not like push back.

Project was enjoyable because I had a good team. Don't get your hopes up with a regrade. They will just argue with you and say you are wrong.

i work as a database admin and got a B. I'd skip if you can.

The worst core class for the CS track. I've taken four core classes so far.

Like all the other review have stated, this class is not hard if you have a good group. However, if your group sucks, then you are screwed. I almost drop out of this program because of this. I had to carry the whole team for phase 3 and worked very hard to finish it up. So if you are unlucky, don't pick this class.

There are a few other things I don't like about this class.

1. Structure doesn't make any sense. You are having either an exam or project phase due every two weeks. Phase 1 and phase 2 are essentially just writing project plans. Phase 1 is about 30 pages and phase 2 are writing sql. All of a sudden, right after you turn in phase 2, you have three weeks to complete phase 3, which is code a full stack frontend and backend program from scratch. Within that three weeks, you also have an exam happened at the same time. If all your team members know what to do and are not lazy, then it's fine, but in my case, my teammates are lazy and not responsive until one week before the project is due. And 2/4 team members doesn't know anything and basically freeloaded.
2. Exam is not a good way to test your understanding of the material, but more like a riddle. The practice exam is not similar to the exam level of difficulty. The exam questions are not clear and precise. All the exams are fill in the blank or choose multiple answers. And you need a mirror.
3. Team grades doesn't make any sense. They have two different grading system. one is the team evaluation, in this case, is solely based on how your teammate rate you. You have to make sure your teammate like you, otherwise you'll get a bad grade on this. This is 12% of your grade. The second grade is the project grade. Everyone gets the same grade. It doesn't matter how much work they put in. Your teammate could work 3 hours total for phase 3 and you could put in 100 hours. As long as one of the teammate give that person a good team evaluation, then they get the same grade as you. The only exception is when everyone in the group give that person a bad review. So if you don't want to put in work, then just kiss up to one other team member, then you are set. Or if two people doesn't do any work, and just give each other a good rating, then they both are set :)
4. Course materials are extremely tedious. It's not useful and applicable in real life work place at all.
5. Professor/TA doesn't really care or respect the students at all. When you have an issue present and tried to resolve it by communicate with them, they just give you the most generic answer. Also, since we are having an exam or project phase due almost every two weeks, they decide to shut down piazza for a while every few weeks, not helpful at all.

Take this class if you want to test your luck!

This course is an easy course if you have any sort of discipline and are a good communicator. You have exams based on a couple text book chapters that you have a few weeks to review and study, and then group assignments that will test your communication skills. As long as you get a good group and complete your work, and have any sort of time management and study skills, you can definitely finish this class with an A.

• Background: I have 8 years of experience as SDE. I got a B, with exam and project scores ranging from 80-90.

I took this course in my first semester along with Advanced Software Testing & Analysis. If I had done more research, I probably wouldn’t have chosen it.

• The content was pretty basic—more like an undergrad course on ER design and server-client app development. I was expecting to learn about database algorithms and more advanced topics.

• The exams were manageable, but the team project required a lot of effort to meet all the detailed requirements for an A. Make sure you’re in a team with both front-end and back-end skills.

• Key Takeaways: If you have a CS background or SDE experience, skip this course. If you’re from a non-CS background and want to learn SDE, databases are important, but this course isn’t the best way to do it.

The most ironic part of this database course? I ended up getting hands-on experience with React. LOL

A relatively easy class but grading is not that good. Easy B but difficult to get an A (myself and a few friends I know got 89.xx and they will NOT round up).

The final exam will be really bad (average ~70), so be prepared to get almost full mark from all previous exams to leave enough margin for the final one.

The team project is a well defined full-stack website. You are free to pick the stacks you like. They dont care about your front end or back end as long as they are functioning well. TA will specifically check your DB outputs from the front end to ensure your DB SQL logics are correct.

I do recommend to attend the OH. Both prof and TA are really nice and willing to answer students' questions and help you succeed. The TA is like 24x7 online and your Ed post can be replied literally right away.

I came with little knowledge about relational databases and learned a lot , I think its a very important course for people without a CS- background , the lectures very good and helpful, I had a good group and I got some experience doing a full stack app using spring boot and react , the exams are fair but I ended up blowing the final exam due to some life issues and got a B , but overall great course !

All the material learned throughout this course was actually very interesting and enjoyable. The staff and logistics made this course a strong demotivator. To begin, no matter what is going on in your life, there will be NO accommodations. As explained in the prior review, the class average on the final exam was a D. You would think they would curve because the most important exam that makes it or breaks it for students had a D AVERAGE. That should be a strong indicator that there is something seriously wrong with the way this class is structured. The was no regard for student's life outside of school, shit happens.

TLDR: Grading is extremely harsh and strict (class average of D on final exam with no curve). No accommodations no matter what is going on in your life. Little to no regard for student life outside of school. Material was very interesting.

Honestly my least favorite class I have taken ever. I feel like in this class the logistics matter more than the knowledge you gained. Like other classes, yes you learn and it is useful knowledge. However, the professors are extremely strict about grading and timelines. Which I do understand to a degree because it is a cs program, however, there is absolutely so flexibility. To give you an idea, the class failed the final this semester (average below 70), however, the professor would not curve the course. Saying something along the lines of following tradition and its not being harsh etc. And since its a group project, you better hope your teammates can do a good job or else you are not going to do well in this. I got the short end of the stick in that area.

The lectures provides basic concepts and doesn't help you receive better scores since many questions are way different than what you learned from the lectures.

They seem to study very hard and focus on how they can give you bad scores. You will see very different diagrams in the exams.

If they want to make sure the students fully understand EER, the lectures should provide more and complicated practices with EER. The gap is way big between the lectures and the exams.

I've not seen anyone who withdrew the course so far but two from the group decided to withdraw the course because of the exam results.

Good luck!

I enjoyed the project portion of the class, but if you have bad team members, then the project is double the work and can be pretty stressful. I recommend getting a team member good with SQL and one familiar with building an application (i.e. a web app or desktop app that interacts with a db)

The exam and book was terrible and I pretty much watched youtube videos to learn the material. The course videos are ok, but you would have to watch youtube videos to fill in the gaps.

Initially skeptical due to its poor rating, I entered this class with low expectations. However, upon completing it, I've come to regard it as one of the most rewarding module I've taken so far in OMSCS (so far I've completed 5 modules).

In our group project, we opted for NextJS, learning a new framework that expanded our skill set. The project itself was robust, encompassing frontend, backend, and database components, and I got to learn from my teammates throughout the process. My team members were all from the same city, we were able to meet in person, making the course more enjoyable.

I have worked in T-SQL databases as a full time job for over a decade and achieved an MCSA, so figured this class would be an easy A. I was hoping the class would either teach things I could incorporate into my work or that were useful for someone looking to utilize databases in their work.

I was sorely disappointed. The class is focused almost exclusively on the logic branch of math. We were not only discouraged from utilizing check constraints, we were disallowed from creating views or stored procedures. In a database class, it was required that we have a web front end, rather than simply direct presentation via query engine. So, not only did I not learn new things, I don't think anyone who took the class is any more prepared to utilize a database than they were when they started.

TAs do not appear to be strong in SQL. Every office hour before exam, students ask what has to be the same question every single term "explain question x from the practice test." And yet, the TAs have no idea what the answers are. Answers to questions on Piazza are often questionaband sometimes conflicting.

For project phases, it appears there is a very specific expected EER model handed to TAs, and if you don't match to it, you lose points even if your choices are valid. Since we scored "high enough" we were uncomfortable asking for a degrade just so we could get scored lower for some unknown issue.

I got an A, but was so annoyed by the entire experience, I would not recommend this to anyone who can possibly avoid it.

Great course for learning the history and theories behind SQL.

Lessons are good for basic introduction to relational algebra, calculus and SQL. However. you will be expected to learn much more advanced queries for the project.

Project is open ended as you get to choose how to implement, Our team had very little experience in web UI, so we used Java and Java FX .

4 exams were tough but doable if you learned the topics. Each exam probably had 5% to 10% very tough questions.

Office hours with Dr Mark were actually very informative and enjoyable to watch

Help from TAs was hit or miss, but mostly helpful

An A is tough in this class if you are not a great test taker.

There are 4 exams and they are difficult and technical but doable.

The course is overall not bad. The project is heavily focussing on application development with SQL query stuffs. Make sure you have a good team with desktop app or web app(specially on front end), otherwise this course is a nightmare for you. If you are knowledgeable about database, skip this fundamental course

There isn't much structure to this class. You're given a team and a project and it's on you all to figure it out. Like all group work - the biggest challenge is wrangling to team and getting folks to participate. The exams are full of gotcha nonsense questions and should be revamped. I'm looking at my first B in the program in a very stupid class to get a B in...

The course keeps you on a hook with its weekly timed deadlines. Got 89.5% (B) barely missing A due to a few tricky worded questions on the last exam. Got unlucky with dysfunctional project team who had little or no (!) computer programming background. So, the project was hell; ended up doing most of the project work myself to get better grade. I won't be surprised if my teammates who didn't contribute to the project but spent their time memorizing for the exam got better grades! Timewise, the team project (including team meetings) took 110 hours, and the lectures took 30 hours overall. The course has potential but the grading is a complete mess.

• Project should be easier but unnecessarily complicated releasing information/data in phases! Data is released 3days before which makes it painful if your design/model is right. Pick team wisely who can code front end
• last exam is a nightmare!
• Only course in OMSCS so far which is setup for student failure. Missed A by 5 marks from last exam

This course was great at laying an understanding of the fundamentals for databases. The exams were very challenging and there was trick questions.

Overall course has some potential but do not recommend this course any more. This course has some downsides .

1. The TAs are mostly rude and course is in full control of TAs . Professor do not have time to look at. I feel TAs are more biased and grading is horrible. If you need support from TAs, you will get horrible reply. I believe TAs are about 50 years and they already retired or completed course or do part time job so they don't care.
2. Exam system is horrible. If you have full watched videos and attended weekly meetings also, its not guarantted that you will be judged fully. Because of project work you wont have enough time to read textbook and you become trap on those.
3. If you aren't lucky enough and you do not have good amount of time. you will be in horrible situation. You can't single handly guide your project. In my case, two of the friends dropped the course and remaining 2 have full time jobs. I couldn't sleep whole night before submitting projects. Hope this situation wont come for all.
4. If you are thinking that you will learn SQL on this, you wont learn. It's just implemantation work.
5. There is no extra credit and no round in the credit.

I didn't care about reviews before and I believe those reviews are very genuine at this point. Decision is yours.

This class has a lot of potential, but I wouldn't really recommend it to the average OMSCS student. You should avoid this class if you have taken an undergraduate course in databases, have a decent amount of real-world experience with database design, or are plainly uninterested in the subject.

I took this class during a summer semester. The course does not omit any assignments or exam topics for the shorter semester and so the course is accelerated from 16 weeks to 11 weeks. Any remarks I make about assignments being difficult or time consuming should be read with this fact in mind.

I really enjoyed the lectures and the theoretical component of database systems. The lectures cover relations, EER diagrams, relational algebra and calculus, SQL, normalization, and data storage/retrieval. The professor's videos are well made and fairly explain a lot of the concepts. The major downside to this aspect of the class is that the exams are difficult to prepare for, since they tend to test on information covered only in the textbook and will use (IMHO) overly complicated examples. There are practice exams, which I would say are about half as difficult as the real exams. Maybe this is not such a big issue in a full-length semester, but I found it very difficult to read the textbook, do practice problems, and watch the lectures in the limited time between exams.

The practical component of the course is a semester-long project where you and a team of other students create a full-stack application. I was fortunate enough to have a really great team so this wasn't so bad for myself, but I can see it being troublesome for anyone who has poor teammates. There is a lot of work to do and all teammates will need to work hard in order to do well. The worst part of the class is how the project is handled. The documentation you receive up-front is imprecise and will require you to ask the TAs for clarification, and occasionally you will read a TA's response to a question on the project which completely upends something you've been working on without issue because the documentation was misleading. If you take this class, the best thing you can do to help yourself is to find competent teammates and begin writing the application very early on in the semester.

The TAs are helpful, but often come off as rude or behave as if they are beneath answering questions from students.

I gave the course a 3/5 rating because it wasn't all bad and had very informative lectures. If they would redesign how they handle the applied portion of the class then it could easily be 4/5.

For the summer semester, I would say it's about a 4/5 difficulty. In a normal semester I believe it would be much closer to 3/5. YMMV.

This class was hard mostly because you are required to read/watch both the lectures and the textbook. Honorlock proctoring service is in use. Even if you do read, the tests are designed to be not so easy. You will find a lot of problems/scenarios in the test that you haven't really seen before in lectures. Apparently if you do the practice problems in the book, you'll be okay. I didn't have the patience for it. Luckily tests are open note (you must take your own notes) so that helped me at least pass (with a mid B)

First of all, it is my 1st OMSCS course and I will say it is a good 1st course for people w/o strong CS background. I managed to get an A in the course while working in a full-time job and taking care of time-consuming personal affairs.

The DB course is pretty much 2-week lecture, then 2 week project time, and then another 2-week lecture - 2 week project time round. I found lecture weeks are less stressful if you started reading textbooks and watching videos early. You will need some practice to make sure you are pretty familiar to all information mentioned in the textbook and video if you wanna get some good scores in exams.

You will need a good team for projects to make life easier. I didn't have a "powerful" team such as some team are full of 10+ YOE SDE. But everyone attended meetings and finished their part as scheduled. The first few projects were not too "hard," but they still needed some time. As for last/final project, we used Flask+mysql. If you are like me who have no experience with these frames, it is better to decide how your team wants to finish the project. Then learn these frames quickly with youtube videos or some informative blogs. It is a good learning process and you don't need to be expert in these frames to finish the project. And it may also take you some time to finish the front end with HTML and javascript if you are not familiar with them. But again, you can finish all of these if you start early and be motivated to self-learn new knowledge.

My only complaint is that the time of last project was intense and if your group had a late presentation time, it is likely to use some time which you should study and prepare for exam 4. And exam 4 is also the most challenging one. The average score for exam 4 is much lower than the first three exams (like 6-70). So if you wanna get an A here, try your best to get more scores in projects and first three exams.

Overall, I found DB to be a good 1st course. The workload is ok. Maybe you won't learn too much if you have a CS degree already, but it is good for anyone who does not have a complete CS degree before. A is also pretty achievable for this course.

I am an OMSA student looking to fill a CDA elective. This course fit the bill and was easily tacked onto another course during the semester. I would say most of the material is pretty basic stuff. I don't have a CS background, but the concept of a database is pretty straight forward. The first three exams were relatively easy, but the fourth was worse than I could have expected, even based on the reviews. I don't believe the concepts were difficult in the fourth exam, but it's one thing to read 4 chapters on normalization and another to actually repetitively put into practice.

The group project was really quite straight forward. Take the initiative to find a good group of people (easier said than done) and the work load is quite light. I enjoyed the group project and luckily had the best peer group team that I have ever had. Find people with a variety of skill sets and work together.

All in all, an easy class to fill your elective if (like me) you are at the very end of your degree and burnt out working 20+ hours a week above and beyond your full-time work schedule and other life priorities.

DO NOT TAKE THIS COURSE

Background: This was hands down the worst course I’ve taken as part of the online masters series. I chose it mainly because the workload looked light, and it was generally pretty light (I spent 5 hours per week and got a B).

Why should you avoid it? If you already have a lot of DB knowledge, this course is very outdated and you will not learn anything. One of my teammates for the project is a software engineer and said he didn’t learn anything new at all.

If you are a database novice, you will be completely lost. Lectures are typically 30-45 min total, and there are no homeworks or any way to practice applying lecture material other than a simplified practice exam leading into each actual exam. Even the textbook doesn’t provide meaningful learning opportunities, nor do any online searches. When you get to the project, especially phase 2 and phase 3, you will be hopelessly lost unless someone on your team has significant database/coding experience. Phase 3 will be almost impossible as it relies heavily on front end design which is entirely out of scope for the course syllabus.

Other notes: The office hours are useless and very difficult to decipher even in the recordings. The TAs are unhelpful, in particular Alex Yanovsky stands out as the worst. He shuts down any opportunity for students to respond to students in Piazza, instead responding within minutes to questions, though more often than not he doesn’t provide a substantive answer.

Exams: There are 4 exams, and you have minimal practice opportunities before each. They are all significantly harder than the practice exams, with questions often many levels above the basic nature of the lectures.

Project: Total waste of time. If you know what you are doing going into the course, you will be bored and unchallenged. If you don’t know what you are doing, it’s almost impossible to learn on the fly. Your only hope to pass the project is by having at least one expert on the team.

It's an "okay" course if you've never taken a database course. The issues pointed out in other reviews are accurate. GT should modernize this course or add an advanced database course covering database internals.

This class made me feel like I was being scammed by Georgia Tech. This is not a graduate level course. It is a crash course on EER diagrams (which is not useful), the very basics of SQL (basic insert/update/delete, simple joins, etc), and an extremely poor explanation of database normalization.

The entirety of this course was contained within the first two lectures of my undergraduate databases course. Which also had 24 more lectures worth of material.

If you want an easy grade, go for it. If you hope to learn about databases, spend your time elsewhere.

The course itself is extremely low work load. No homework, no quizzes, only few lectures. There are four sections with a test each. Each unit is ~4 weeks but you'll finish the lectures in one day each time leaving you with nothing to do other than the group project for a few weeks at a time.

The group project is a bit more involved, you'll build an application that heavily uses database transactions. With a good group its extremely manageable and actually pretty interesting to go through.

The problem with the course and the reason I'm hesitant to recommend it is the awful TAs. They extremely condescending in posts and rarely actually help you understand anything better. And clarification is often needed because the project specs are pretty vague and open-ended which conflicts with the fact that they do have a specific way they want you to do things that they won't tell you.

Also, like some other course in the program, each phase of the group project is pretty heavily reliant on the previous phase. Problem being, that despite the instructors having nothing to really grade, you won't get feedback until a day or two before the next phase is due. Making it either useless, or making you have to rework things last minute.

If you're looking for an easy low workload course go for it, just keep in mind that you're mostly on your own.

It's an okay course given that it covers many fundamental knowledge of databases and the course material is well structured. It is also a course you have to take if you come without a CS background. However, I found myself hesitant to rate this course high by all means.

I spent more time than I should/expect, and most of time is wasted on clarifying the project details with TA, reading the wordy textbook to prepare the exams. In the end, I overkilled it and felt like time was wasted. So, be careful about your time budget and try not be paranoid because there are many ambiguous things you will encounter in this course.

Many have commented on the 3rd phase project, particularly the front-end part, which is time-consuming and somehow not database-related. So choose your teammates wisely, and start early for phase 3, particularly if your team don't have front-end experience.

If you learned database in your undergrad, then you can stop reading. You don't need to take this course at all, there is nothing new compared to your undergrad course.

However, if you background is not CS (like me), this might still be a good course for you. I say 'might' because the course is all about the very fundamental stuff on relational database. It doesn't cover anything regarding the modern NOSQL databases. I know people complain about this all the time, but I am totally fine with it. The college courses are supposed to only teach about the fundamental stuff. You can easily find newer technologies in those MOOC courses.

All tests and project phases are fine except the last phase of the project, where you and your teammates are supposed to build a fully-fledged webapp (front-end, back-end, middleware). Now you can select your own tech stack to do so, as compared to before, where you had to use PHP. But still, if your team happens to not have anyone with front-end experience, that could be a nightmare. The requirement for front-end is hardly justified since this is a database course. Even though the course claims that you only need basic display functionality to show your SQL queries, but still, there is a ton of front-end stuff you need to do. And guess what, the final score is all about your query response, you don't get any credits for the front-end.

that being said, I still enjoyed the project because I got to play with node.js, react and express.js, which was totally new to me. But I understand why people complain it since again, this is a database course.

I am going to break down my review of the course into three sections that of Curriculum, Exams, Project, and TAs.

Curriculum: This course ONLY covers Relational Databases and does not cover any other kind of database architecture such as graphs, Key/Values stores, Column Family or Document type databases. The 90s wants their database course back. In all honesty the most valuable material such as indexing, and performance is kind of glazed over and not very well covered at all.

Exams: To be frank the exams set you up for failure. A full three fourths of the exam material for exam 4 is NOT covered in lectures at all. This course is a masterclass on how to create exams that set students up for failure.

Project: Additionally if you are saddled with a team that is inactive or isn't engaged you WILL end up doing the entire project yourself. You do a live demonstration of your project at the end of the course in 25 min. It is CRITICAL that you get a team that wants to work and actually LEARN the technologies required for the project whatever you choose, HTML, CSS, Etc. Also You are NOT allowed to use any ORM type systems and must write ALL SQL queried by hand. This is not a gripe but rather something you need to be prepared for. What makes this even more difficult is that the requirements are extremely vague in many key spots and if you don't code specifically to their uncommunicated "expectations" you will be docked major points.

TAs: TAs in this course quite simply are jerks. I think that being a smart mouthed jerk is a requirement for being one in this course. It appears that being a TA isn't about helping the students succeed, but rather showing your superiority over others. Also Only ONE TA is actually active on Piazza and he openly desparages students who "Didn't understand requirements". In many responses the TAs don't write clearly.

My biggest takeaways, for this next semester I am checking these omscentral.com review scores and more heavily considering them when selecting my next semester courses, and I am applying to be a TA (we deserve better TA's than this). I look back now and think: why did I sign up for a class that was rated less than a 3. That's on me.

Almost every review of this course here is spot. I have been working with databases for almost 30 years (SQL MSCE certified, all flavors of SQL and no-SQL big data), and this class was frustrating. Probably will end up getting a B, outside chance of getting an A. No, the TA's are not helpful. Every other answer is: we can't really answer you without giving away a solution. Their write-ups and requirements are poorly written (you can be a super DB person but that doesn't mean you can write good requirements). Yes, the exams are "tricky." They tell you "it's not tricky, just read the questions" and then post questions that are ambiguous, leave room for interpretation, etc. Nothing positive to say here.

I really liked the course. I am one of those non CS background students who also had minimal exposure to DB/SQL entering this course. However, I came out of the course having a thorough understanding of Relational DB, SQL and basic full stack developement.

The lecture videos are good and sufficient to do decently on the exams (Although going through the book is always recommended). My only grouse is absolutely no exposure to NoSQL DBs. Rather than spending inordinate amount of time on relational algebra and calculus (which has limited utility), the course can atleast attempt to provide an intro to NoSQL frameworks owing to their popularity and ubiquity.

The main learning is from the group project and therefore it is very important to spend time creating a good team. There will be a dedicated thread on Piazza where people can advertise and recruit for their teams. Your team needs to collectively decide the tech stack to be used to build the application and provides a tremendous opportunity to gain exposure to full stack developement. Some HTML/CSS/ basic web developement framework knowledge is highly recommended as a prep to this course. 15% of overall grade depends on how your team members judge your contribution to the various phases of the project. The TAs seem pretty strict about this and they review an individual's git commits to verify the feedback. Having come across numerous horror stories about people abusing the group project, I consider this as a very positive step.

The grading distribution is strict. Exams are not easy and require effort. The course is nicely balanced between theory and project. All in all a good course and strongly recommended for people with limited DB/CS experience.

As someone with no database design experience, this was a very useful course. Learned a lot about how to design relational databases from scratch. Did not spend that much time practicing SQL nor did we spend any time on any other type of database architecture.

As many have said, having to design a webpage is a burden if you don't have any front-end experience, so choose your team early and carefully.

If you are aiming for an A, I strongly recommend reading the book. The exams use content present in the book which does not come up in the lectures. One or two questions each exam came from the book (out of ~30 questions per exam).

My only real complain is that the course could use a lot of polish in many areas. It often feels like we were given the first-draft of content. For example, exam 2 introduced new notation in they EER diagram we were provided which appeared neither in lectures nor in the book, it also had some aggravating formatting issues: some of the LaTeX images presented were too long and overlapped text on the side-bar such that it was illegible.

The TAs and the Professor all seemed pretty friendly, and they were very fast to respond on Piazza (though how helpful the answers were varied).

If you want to be able to design a relational database, take the class; the pros outweigh the cons.

I wouldn't recommend this course to anyone. The lecture is outdated and the professor is still trying to teach you how databases looked like 20 - 30 years ago. There is no modern database technology being taught in this cause.

Final project is joke considering this is a database course. You will be required to build an application which supports a lot of frontend features and must meet the logic at backend as well and it needs to record the data correctly into a database. They just dump you a set of php code that works on a project a few years back and to us it wasn't helpful at all. You won't be taught anything about full stack development but they expect you to build everything.

Also the project is poorly defined, we've never cleared about the requirements and had to guess a lot things.

Exams are designed to trick you even though you thought you've well prepared. These exams questions are meaning less and you won't get any useful knowledge from it.

It's my first course I've spent a lot of time just trying to get a B out of it. Fortunately, one of my teammate was a full stack engineer and he basically carried us out in the final project.

All I want to say is about the grading policy. Guys, do challenge every point, no matter how tiny it is, in your exams, in your each phase of projects! They will not show any mercy to your final grade, be it 89.5, 89.7, or 89.9. They all fall into B. No round up.

The policies of managing this course is the only issue of this course. Otherwise, it will be a standard good course. They try to justify their policy by emphasizing how big this class is. Yes, we all know that. But it still sounds like what a dictator would say in why he rein his kingdom in the way that the majority is not happy.

This was my first semester at OMSCS. I enjoyed most of this course since I wanted to learn more on the fundamentals of databases. I build and work with databases in a non-SQL RDMS, but I was really missing on the fundamental principles behind what's happening in a db.

Lecture Videos: Quite well made, sometimes funny as well, but not enough to get a decent grade. Don't just sit and watch the videos. Make your own notes and you can use those notes in the exams as they are open-notes exams!

Textbook: It's a really good textbook but sometimes goes much deeper than what is needed for this class. A definite must read if you want to get a good grade

Exams: 4 exams in total, all multiple choice but the ones that have multiple options are tricky when it comes to grading them. If there are 2 answers and you select 1 correct and 1 incorrect, you score 0. It's a bit unfair but try to be careful and smart. Exam 1 and 4 are the hardest. Exam 1 is very high level concepts that might probably be ok for someone without any knowledge of databases, but for someone that does know a thing or two, they can get a bit confusing. Do try the practice questions well in advance and also right before the exam itself, sometimes questions are pretty similar. Do take your time during the exams and read the questions and possible answers very very carefully. I am not a native English speaker but that didn't stop me from getting good grades by carefully reading.

Project: It's one large project broken down into 3 phases building a full-stack app with a database backend and web or desktop frontend. It was a simple project yet it was challenging at certain areas and making you really re-read and think. I think Phase 3 was an almost complete waste of time, i.e. to actually build the app itself because you have everything for the database up to Phase 2. It's certainly nice to see the thing finished but IMHO it would serve better if they scrapped Phase 3 and run another project to repeat Phases 1 & 2 but harder and all in one go. One more tip for Phase 3, try starting it before the end of Phase 2. If you can get the backbone of the setup and basic feel and look of the app it will be a walk in the park from there on.

Piazza: Most other reviews talk badly about the TAs, I won't! The TAs do a pretty good job and are always helpful. HOWEVER, this course has been run for many many years now, as a result they accumulated a lot of knowledge from past semesters and they have long but excellent instructions for just about anything. Read all those instructions carefully and don't ask silly questions. Read the threads on Piazza for practice exam questions by other students, I found very useful info in those posts right before sitting an exam.

Project team: Find a team soon as all groups need to be 5 members (unless the total number of the class isn't divisible by 5). I found it really hard to get on team very early on as there aren't so many european students to be able to fit my schedule. Eventually we had 1 complete slacker in our group, another one that wasn't much of a help but did genuinely try to offer help, and then myself and 2 others that took most of the burden. Try and have regular meetings with the team and divide up the work. Most of the work in Phase 1 should be done in group with some division of labour there but Phases 2 and 3 can be split up in terms of work so y'all can work separately and then bring things together.

This course could certainly use some slight modernisation but I think mostly the whole program and us of course would benefit from a second yet more advanced database course as a sequel to this one. Also one that would include NoSQL as well as there isn't any in this one.

My first class in OMSCS, BS in mathematics with no formal CS training beyond machine/deep/reinforcement learning type courses. Course materials are somewhat shallow and only covers SQL database. Exams sometimes focus too much on definitions rather than practical matters. But not very hard to get good grades or full score if spend some time preparing (~15 hours for each exam, got 98, 100, 100, 96 for exam 1,2,3,4 respectively.) For exam 1 & 4, should definitely read the related textbook chapters I like the course project, especially the third phase which requires full stack development (website+database, sql+python flask+javascript) and I learned a lot from the course project. TAs are too picky in terms of project feedback (especially the first two phases), some requirements do not make any sense, for example we got points deducted just because we wrote a separate function to calculate something. I do not interact with TA too much on piazza but sometimes I feel TAs are too aggressive.

Let me start this by saying I’m probably getting an A in this and I’m also quitting GaTech because of it. The instructor and TA’s want you to fail in a rather easy, irrelevant to a certain extent Intro to Database course. They say the questions are not meant to trick you, but then - for example - ask you to round to the closest integer on the only question that did not need rounding. What’s worse is that there are mistakes in some of the questions in the sample quizes but one of the TAs - namely Alex ( who doesn’t bother to review or correct his english when replyings to student questions) almost mocks you for starting a valid discussion. I suggest also the professor give it a rest and retire or update the course to be more relevant. The course is about normalization of data in a world where denormalization has become a thing a pattern. The most decent part of the course are material in Chapter 4 - but they are given the least amount of time. Oh yea one more thing, they try to create their own SQL in some exams just for fun. What a pathetic waste of money. Id have rather done some Udemy or cloud certifications.

Really disliked this class. The only thing that's good about it is the professor is funny and so the lectures are entertaining. But once the exams hit, you'll feel like an idiot for laughing during the lectures. The exams cover stuff not found in the lectures but in the book which has a lot of reading. Exam 4 was incredibly difficult but the other 3 were manageable.

The TA's are annoying as well. Instead of responding in Piazza, they'll say, "just watch the entire office hour", when a 5 word answer would suffice.

You'll get dinged for forgetting small things. THE TEAM SURVEY IS WORTH POINTS. It's not optional.

My group bailed on phase 3 of the project and I basically had to do it alone with one other group member. The project was designing a full-stack web application so you need to know REST, the basics of API development, some frontend tool to design your UI, and database queries. NOT FUN. On top of this, you need to get 4 group members all on the same stack. Then you have to live demo it in a presentation.

It's a pity this class is designed the way it is because databases are so integral to day-to-day work.

I really wish this class was designed in line with other classes where you use an autograder to create a DB, queries, etc. I could see this class being amazing, but it is what it is.

Total waste of time. This class is very easy but it is not certain you will end up with good grades. The group project is total scam as everyone gets the same score whether they put the same effort or not. You will hardly learn anything from the group projects it is just time consuming. Furthermore the class itself is easy as there is no other homework and reading are pretty small compared to other courses. However, the exams are completely hit or miss. They are designed to be tricky not to understand how much you actually know of the material. Each exam question is worth around 5 points so if you get unlucky on any two of these trick question you loose points to get A in this course. Like everyone has mentioned it is an easy B class that you can take with a hard course but still complete waste of time for a grad student. Last but not the least TA's are also not helpful at all, this course is a complete mess.

This class was a very intro to relational databases class and not suitable for most people who have had practice with SQL. I recommend Advanced Operating Systems or High-Performance Computer Architecture instead.

The class really only covers 1 thing, databases. Its great if you want to get a better feel for SQL but thats about it.

no HWs (big plus) major project throughout the entire class with 3 deliverables 4 exams (exam 4 is by far the most tricky)

Worst thing about this class is there is NO CURVE, its easy to get a B in but very hard to get an A.

To see my full review on the course, check out my youtube channel: https://www.youtube.com/watch?v=cXp4ZWU1fV8

A lot of complainers in these reviews... yes the exams are tough, but they are fair. Yes, TAs can be blunt in responding to Piazza posts; it's not a big deal, just get over it. Yes, the group project involves doing web page development in addition to database design; learn some php.

Watch out for exam 4 as it is pretty difficult and you'll likely be focusing on the the group project at the same time.

This was my first OMSCS course. If this is really "the worst class in the whole OMSCS program" as many reviewers are commenting, then in am in for a good experience. I took this course to solidify knowledge about databases I have picked up through work experience and it was a success in that regard. My one complaint is that the first half of the course is a bit too "formal mathematics" (i.e. I wish it got into SQL faster).

Before taking this class

1. My DB course-related background: Know SQL fairly well, have front end experience, have no DB design experience, didn't take DB class before
2. My goal: Have a thorough understanding of the database system design. Expect some hardcore stuff with limited SQL contents

My DB course experience

1. Lecture quality: The professor explains things well.  The video is good. 
2. Exam 1: open book. Questions are not hard. However, for non-native English speakers, even you are fluent, it would be medium-difficult since several questions are really testing your English, not knowledge. 
3. Exam 2: open book. Questions are clear. If you know SQL, it's pretty easy
4. Exam 3: open book. Questions are clear. If you know SQL, it's pretty easy
5. Exam 4: open book. Medium. You should read the book. More than 30% of quiz questions are not covered in the lecture and are purely from the textbook. Make sure you understand book fairly well
6. Team Project: Three phases, the first one is to read the doc and design some flow, the second one is to write SQL, the third one is to build the website and complete queries
7. About TA: I appreciate the support from Alex. He is willing to answer your questions and provide guidance very quickly, even at midnight - I assume he is in the US. But sometimes I do feel he is not in a good mood when answering questions. Generally, I would give a thumb up for him. I know some students are unhappy with him because he was strict on their team project, but I think he did his work well.

The reason I CANNOT like this course

1. Team project: The project is time-consuming but not rewarding, and there is really no penalty system for free riders. It does provide a team evaluation form, however, you know the free riders also evaluate you, and they will get the full score on the project parts no matter what. The most time I spent on this course was on the team projects since some teammates didn't wanna do their part right. I know they may have a different goal for this course but I am still unhappy with this. As for the project itself, I didn't learn much from the project. It turns out to be a waste of time. If you know reliable people, you may have a better experience. 
2. Course contents: I would expect more hardcore contents. The contents covered in exam 4 can be extended, covered and taught more deeply. However, the recorded lectures are a bit shallow

Some data

1. Totally spent ~200hrs on this course
2. My target is A. End up with A
3. Team - Me, 2 reliable teammates, 2 non-reliable teammates

My final thoughts

1. This is an easy B but hard A course. If your target is B, you won't have much pressure and may spend much less time.  If my target is B, I probably would spend less than 5 hours a week.
2. I will not take this course If I can choose again.

Easy B, Really Difficult A, but a good course. This was my first omscs course. Exam1, and Exam 3 are easier. Exam 2 is difficult, Exam 4 is really really difficult. The project phases are fine for 1 &2 but the final phase 3 is really difficult. It takes an exponential amount of time and involves web development. And we had issues were the most of the team were not developers. So get a team who is proficient in coding or be willing to spend a lot of hours doing the heavy lifting. You need to do a bit on set theory; fortunately no proofs. If you go thru the lecturers twice and read the text thoroughly twice for the exam, then you have a chance of getting an A. Overall, I enjoyed it. I was in mid B's till the last phase and exam and slid to a low B by the end. Exams are tricky so read the textbook thorough. Textbook is authoritative and lectures are just an overview of what you need to study. It is a good course to start omscs if you are planning to ease into the program. The theory did clear up a lot of issues I had in EER to relational table mappings.

I learned a lot in this class and had fun working on the group project. I put a medium amount of effort into the exams and a lot of effort into the group project and made a B in the class. I believe I earned the grade I deserved and I liked the course. Overall the reviews are correct for this class. It is very important to pick a good group. I was the only one with web development experience, but our team was strong in other areas and made us a well rounded group. Stick to a regular weekly meeting with your group and work to hit the deadlines early, and you will be fine (we made between 94-98% on all phases).

The exams are tricky. Each question is worth 4 points so if you miss 3 (or get partial credit on several) there is no chance to make an A on the exam. I really do wish they would just double the number of questions on the exam, I think that would be fairer, but c’est la vie.

Its very easy to make a B in the class and somewhat difficult to make an A. There is no curve, but they they will adjust “rounding up” a bit it seems. Several folks on my team were right on the edge of a B and an A and ended up with an A for the class.

This was my first course in OMSCS, and I’m not going to lie, I didn't mind it. The name of the game is getting a good group though. At the beginning of the course, you are allowed to post on piazza and find people to work with for the semester long group project before you are assigned a random group and I HIGHLY recommend that. I was able to find 4 other members in my time zone who had similar schedules and wanted to perform well in the course. This made the group project easy and all 5 of us contributed equally, made everything so much easier and the end product actually turned out really well.

I liked the lectures although they were not super helpful when it came to the exams which were sometimes tricky. I believe that the only way to secure an A in this class if reading the book thoroughly.

The TA/instructor responded to all of my questions quickly which was nice. I agree with some other posts that say this class is a hard A and an easy(ish) B. Definitely not a bad class though if you set yourself up well.

I have seen many sentiments about this course which I chose to ignore, thinking I could objectively take it as a core course for the computing systems specialization. These sentiments are true... all my group (project) members withdrew... This was my 5th course and I believe this is the worst OMSCS course and not sure its actually been retained as is. From the content, the TAs and the overall learning experience.... Unless you love regrets, keep off!

Please avoid taking this class. Again, please avoid this class unless you want to be attacked when you ask questions on Piazza. For course materials, the videos cover most of the basic knowledge but it is not sufficient enough to let you get 90% score. You have to read the text book carefully and have to be able to rephrase every sentence so you will understand what the questions are talking about in the exam. The next part is a big part for TAs and the instructor. Since you guys help me a lot, we should help you improve your course. First of all, I think I am qualified for the position of TA for this course because I am able to set up an auto response of "Please read the spec/textbook carefully. " so every questions will be resolved. Secondly, if the students keep asking me to clarify the statements in spec, I am able to reply "Don't play the game with me. " and they will drop this class to avoid fail the course. Thirdly, if a question starts from "Can you please ...", then I am able to reply "No. " as soon as possible to avoid waste of resources. Fourthly, I am able to keep my rating at a high score and most of the reviews will be positive because I have a script to post reviews here saying something like "Nothing wrong with this. Shame on the students who don't take the time to go through things first and expect others to baby sit!" and "Alex is the best TA I have ever met. ". I think I met most of the TA qualifications of this course so please hire me so you will improve the course in this way! I need money!

1st OMSCS class. Took this class because I thought it is an easy class and wanted a smooth start. It's not. It is an "easy B" but for sure not an easy A. ​Eventually I got hard-earned high A (> 95) but the experience is horrible.

Trust me, only 20/30% people got A. It is NOT an easy A. It is NOT an easy A. It is NOT an easy A.

Check the rating of the class, it is currently the “TOP 3” for CS-coded classes. There is a reason for that. I regret I did not take the rating seriously when I made my choice.

STAY AWAY STAY AWAY STAY AWAY from this class if you can. If you want to learn DB knowledge, there are happier ways to learn it.

You are tested on a lot of concepts are not covered in lecture/textbook. For Exam 1, you are tested on your English and not your knowledge. Trust me, it is not because you do not know the content, it is because the words they use create a lot of confusion/ambiguity. AND they are NOT improving it. Your exam 1 will be a frustrated one.

Some TAs are nice. I have to say the TAs’ reply come in very fast, in minutes or seconds, but sometimes RUDE and TOXIC. The head TA is a dictator (and the professor perhaps) as if there is only one answer to the project. It is not, or rather, the concepts are not clearly explained in the lecture/textbook, so many people have to ask in the forum to literally GUESS what he want. We are not learning much from this, simply a waste of time.

I am sorry the head TA. If it is a group decision to make the project/course exam like what it is currently, I am sorry you are blamed simply because you are the one replying the posts. But again, when I think of the tone/words you (and some other TAs) used, I do not feel sorry any more LOL.

Even worse, if they think the textbook is not sharing the same ideas as theirs, the textbook is wrong. LOL. Write your own textbook and give notes.

Very concise lecture videos, that however means you have to read the textbook very carefully. I read every single page and took my note (Exams are open notes). It took me huge amount of time reading the text and summarise it. Tiny portion of it is tested (they really test the tiny details), but you have to invest a lot of time for it.

The professor is a nice old guy and I am sure he has good knowledge in this domain. However I have to say he has little or no incentive to further improve the course. In the reviews, you can see repeated feedback for many semesters.

The team evaluation is a joke. Only 1/2 team members out of 5 worked on the project. The free riders will share the same mark as yours, with very insignificant punishment. Even worse, if they are not happy, they can rated you down. IT IS A JOKE. So, choose your team wisely, or pray hard.

The project has 3 phases. Phase 2 is useful because it forces you to write a lot of SQL, if you contribute. Phase 3, 15% of the total grade, is just front-end coding. PHP code sample will be provided but you do have freedom to choose your stack. Good exposure to FE but really, this class is about DB and FE should NOT be the main focus. I had to spend huge amount of time to make sure the user experience is good, and make sure the selection, button, and the form work.

Let me stress it again.

You will not be happy when you take the class, and for sure you will be frustrated and doubt why you have to go through this.

STAY AWAY please. Your life will be happier without this class.

Well. This is my first OMSCS course and I don't have too many options so I took the Database. I got a hard-earned A.

I didn't look through piazza frequently and preferred to ask questions in groups and slacks. Therefore, I didn't interact with TAs a lot. Most negative review complains about Alex but I'm sort of lucky that Alex didn't grade any of my projects. Overall I feel OKAY with the team.

The exams. The team will tell you which chapters and lectures are covered in the exam. HOWEVER, It doesn't mean that it will only test contents covered by lectures. Especially exam 1 and exam 4. It's about 4-5 questions that aren't fully covered in the lectures. But it's time-consuming to read the textbook thoroughly to just remember some concepts. People feel it's not worth it so they usually only watch the lectures. That's the main reason why the average score of exam 4 is pretty low. BCNF isn't well or fully explained by the lectures. But it's avoidable if you find other resources as supplements.

I don't like ambiguous question descriptions in exam 1 like may nor may not. It may not be a problem for a native speaker. But since a lot of students point it out in previous semesters again and again, isn't it better to fix it? This course is about the database not about wordplays.

Why doesn't anyone complain about the team evaluation here? Do you all get a good team? I'm jealous.

Although TA said you can reflect a teammate who made no contribution in the team evaluation, IT DIDN'T WORK! Freeriders still get the SAME PROJECT SCORE without any contribution. If the team evaluation is the way to report the free-rider issue, isn't their project scores proportion to their team evaluation score?

Like if you get full points in team evaluation, then you get full points of your project score graded by TA. If the free-rider gets 20% in the team evaluation, then they should get 20% of the project score. However, the fact is that free-riders still get the same project score, but just one or two points penalty on their team evaluation. THAT'S NOT FAIR.

The reason why I felt okay with TAs is simply because at least they did their job to answer and explain questions about projects and exams. And their drawbacks can be avoided to some contents.

I felt it sucks because of the awful teammates in the group project and these free-riders are INEVITABLE SINCE THEY ARE IN YOUR TEAM. It's not the fault of this course but there is no effective way to get rid of them. They just did nothing and didn't quit. You have to tolerate them until the end of the semester or you quit.

I had to write most of SQL and PHP on my own during the thanksgiving holiday and treated it as an independent project. I got a great score due to my efforts and so did my free-rider teammates. IF I GAVE UP, I WOULD GET NOTHING. IF I WORKED ON IT, THEY COULD GET EVERYTHING. BULLSHIT.

Overall, the TAs are okay and their drawbacks are avoidable. The exams are acceptable. Project material is outdated but moderate. I did learn a lot from this course and made a project that can be put on my resume.

My teammate sucks.

I am a data engineer. I have spend 4+ years working with dbms and document based systems. For the most part this class is a nonsense. The material is outdated, the delivery is poor and the structure of the course does not make sense. The course covers only a very narrow range of rdbms concepts but it somehow manages to confuse and complicate things to the degree of disgust. This is due to poor organization and delivery of the material. Instead of creating a graduate level db class to broaden students' knowledge of db systems they took an undergrad class and filled it with unnecessary complexities to increase the error rate of the exams and artificially keep the class 'hard to pass'. I feel this is the only motivation behind such a poorly designed class. Whoever created the class was just too lazy to create an interesting and engaging course of a graduate level material. The video lectures cover only a tiny part of the textbook concepts but they are pretty much useless because the questions in the exams (exams are a separate story and riddled with tong-twister questions) that are not covered in the video lectures. During office hours and in piazza the prof's and tas' attitude is basically 'ask us what you don't understand', then when someone asks to give an example they amazingly are too often not able to come up with a clear answer and example. They would spend 20 minutes on debating among each other about the interpretation of the question and the right answer. One would think with so many years in academia and education wouldn't it be easy to have some examples for students. Course also involves a project which only partially touches db design. Large part of the project is building a web application which in my opinion has little relevance to the course. Instead of spending so much effort on the web development the course could cover other concepts like partitioning, distributed dbs. Just avoid this class.

There are aspects of this course I liked and parts that I loathed.

My background: Data scientist / engineer at a large company. I have several years of full-stack experience. I took this course to learn more about database theory and design.

The good: I actually enjoyed the material, and I thought the exams were very fair. Folks here complain about word choice, but semantics matter in a domain that draws heavily on logical concepts and representations. If you truly grasped the material, the word choice on the exam isn't tricky at all. I'm genuinely excited to apply knowledge from this class to the design of data models in my professional life.

The neutral: I do wish they touched on more modern topics: NoSQL, distributed systems, sharding, replication, etc. As a grad school course, this could go deeper into the actual optimization and data structures used in databases.

The bad and the awful: The full-stack web application for the group project was unnecessary and bore no relation to the course's content. Phase 1 (designing an EER) and Phase 2 (abstract code, data model, etc.) were topical, but the actual implementation (Phase 3) went overboard. This is a database class not a web development class. I spent 30+ hours a week working on our project, and I am an experienced developer. We used React and Flask as our tech stack. My teammates were great, but several of them had zero development experience and had a ceiling to their contributions. This class needs to dial down its specifications for the final project.

There are a lot of comments about the TAs in this course. I tried not to engage with them, but when I did, I found them rude, curt, unprofessional, and occasionally helpful. With that said, I also saw plenty of inane posts on piazza that warranted some of their responses.

My final grade was an A, but it was a hard earned A. I don't know if I would choose this class all over again, but I'm not upset that I took it.

Also a note, it's hard to believe that some of these negative reviews below weren't posted by the same disgruntled student over and over. For example, the word "disgusting" is used in several posts to describe the TAs. It is a very odd word choice in the context of reviewing a course.

I know there are many reviews and I still want to leave my own review. The class overral is not good to be honest. My backgroud is a multiple year experience SDE in FAANG. I have done some work with databases. The below are my opinions: Pros:

1. I don't know. Many stupid TAs?

Cons:

1. The TAs are picky. They don't respect students' opinions and response very rude.
2. Too many reports. I would say we spend same amound time as coding
3. The videos are not very useful, the lectures are not very clear
4. Not much content on this class. Even the SQLs are quite straightforward
5. Database is a very interesting topic. Somehow the professor and TAs together makes us not interested in this field

I don't recommend this class for people who are either new or experienced to computer science. Database is important but you don't have to take this course to learn this topic. Many online materials are useful than this course(I have to google and watch youtube videos to learn this course's topic as the course's videos are not clear)

I was about to write my negative review for this course, but found it is not necessary for me to mention again. If 8/10 are bad reviews. You can imagine how terrible this course is. Please avoid taking this course if you can. Save your life to do more meaningful things!

I am a software engineer in a big tech company. I have been working extensively with Java, large scale distributed software systems, multiple types of front-end techniques etc. over the past 5+ years. I took this course since I've rarely had the chance to work on relational databases and I believe it is still a fairly important part of the software industry and this course might be helpful for my career. This is my first OMS course and I ended up getting an A grade. Starting with this self-introduction is to prove that I have enough computer science related knowledge and proper problem-solving skills to understand the course material, tackle the course assignments and exams, and -- properly evaluate the performance of the instructors.

• Course Materials The lectures and textbook are OK. Most of the lectures covered the core content that corresponds to the goal of this course. They are straightforward and concise enough to understand. They are also very helpful in terms of helping us tackcle some scenarios in our final project.

• Exams Exams are difficult. Not because the concepts themselves are rocket-science-level hard to understand, but beacuse there are not enough questions or examples to help calibrate/deepen the understanding. Oftentimes we need to seek for external resources to fully understand the reasons for some correct answers to be determined. Exam 4 is the worse. The lectures themsleves were fairly simple and straightforward. We've spent a large part of the time watching Leo tearing up phonebooks just to learn the binary search algorithm, which is too much time for too simple of a concept while there was not enough explanation to the more complicated concepts like the NFs.

• Projects The projects themselves are OK. It's good to tackle the problem starting from ambiguous business requirement, to refining the question, building up the domain and the EER and finally implementing the product from backend to frontend. Although it is so-called a full-stack product, it really can be as simple as some php scripts embedded into an HTML. I still learnt a lot from it since most of my work has been dealing with the backend services and not frontend. I am happy with all my teammates. Although most of them have less experience dealing with software development, they all worked hard, took the initiatives to learn and grow, were open to feedback and communication and were very responsive. It's been a pleasure working with them.

• Instructors TBH, this is pretty much the most unpleasant and difficult part to deal with. I'd say this is part of the reason that the projects are hard to work on. The head TAs are pretty rude and arrogant, and sometimes so is the professor. There are a couple of times when the students posted questions trying to clarify some ambuities in the homework spec while the response from the instructors are "please read the spec more attentatively." I can give a very detailed example since I had the same question and found the post on Piazza: a student was asking about whether we should assume that a vehicle would only be sold by the store once. The post was created in late September where the first version of the spec has not mentioned that assumption at all. The instructor responded "please, read the spec more attentaticely" while THERE WAS NO SUCH CONTENT AT ALL. And a couple weeks later, they probably realized that they missed that part so they posted updated versions for the spec to make that up. There are also a lot other examples throughout the Piazza forum where the instructors answer the questions with arrogant attitude where they could simply response with neutral lanuage. If I could paste more screenshots here, I would. As an engineer who has been mentored by numerous smart and experienced senior/principal engineers and has also mentored multiple junior engineers, I want to say, head TAs like Alex and Peter, this is not how you should treat students who are asking questions and trying to get help.

Overall, I don't recommend this course. Relational database may still be important but it doesn't mean you have to take the course to become a qualified CS student. Take some other courses that you can both learn and don't have to suffer from other peoples' bad personality.

You will learn EER, IFD, SQL, maybe PHP (if you choose to) in this course. You will get some full-stack experience about how database works. Exams are not easy. Good teammates are very important.

It would be a much better experience if TAs are not constantly attacking students' attitude and efforts on Piazza. The teaching atmosphere is toxic - discouraging any questions (since TA believes it is a shame if you ask any), not providing any constructive feedback (but only rambled on with loads of nonsense), and not giving clear explanations for projects and refusing to clarify. They just enjoy setting up traps in exams and projects for you to fall into. Completely disgraceful.

One good part about this course is that our instructor Leo shows up in office hours every time in person and he will answer your questions in a detailed and informative manner.

If you want to take this course, it would be a better experience if you never went to Piazza and avoid interacting with any of TAs.

I am posting to echo to the prevous comment which started with "Overall I liked this course and I'm very happy I took it. "

I just want to let you know my feeling: the tone from him/her is very similar to some of the TA's. I highly doubt if he/she is a student who took the course this semester. Instead, I think he is Alex. I have clicked the flag icon on the top right corner.

Agree with most of other negative reviews. For me, I am typically someone not very active in Piazza or interaction with TAs but rely on other materials to help myself, but in this course, the interactions with TAs make me, in a polite manner to put, feel offended and disgusting. I am also a TA teaching other subjects in another institution, but I've never seen any other unprofessional teaching staff, both professor Leo Mark and Alex, Peter included, around myself or my colleagues.

1. The teaching staff are very arrogant, and you will feel they DON'T know how to talk to people. In a private post, I asked Alex to clarify about the project spec, and drew a diagram to explain my question. The reply I got was "That is too much information for me". Hardly believe this is something a TA can reply. Trust me, you will enjoy many more "classic" replies if you take this course.
2. Their organization only takes into account their convenience. An expression you will often see in their posts is "Considering the volume of over 500 students, it would be a heavy burden if ...". We pay you the tuitions to get your help in our study, if you feel there are too many students, you can complain to the department. It is none of our business to consider how many you need to serve. I pay, and I deserve, just this simple.
3. The TA staff are very stubborn in their grading. They are very persistent regarding the EER model and diagram. Actually as Leo himself acknowledged, this is a heavily outdated tool. But you must follow their grading favor and follow the only acceptable answer to earn credits.

Besides, the topic for this course is pretty outdated. Of course, this is not a big issue compared to the unprofessionalism of the teaching staff. NoSQL, partitioning, database replica, and other very important industrial topic, are not covered at all.

In summary, by the time I write this review, this course enjoys the second lowest rating on OMSCentral. There is a reason for this, and the major reason I feel and experience is the highly unprofessionalism. The other aspects are doing OK, but the teaching staff? Terrible.

Overall this is a good course. The TAs are mean but they reply to the questions usually in seconds. The exams are hard and don't curve. So the average grade is low. But I have learned a log from these exams The lecture materials are moderately helpful. It is somewhat too easy so I have to resort to external materials The project is the hard part, especially the Part 3. Be aware of free riders! I have taken 3 courses already and each one of them have lots of free riders. I am desperate when I heard most of my team mates don't know a single line of Python or PHP. Be prepare to take more responsibility in the group project. I spend 30+ hours per week for the project. But it is the project help me learn full stack development, Should I thank free riders? lol

To be honest I understand a lot of friends and classmates don't like this course and it does have some frustrated moment (for example, some questions in the exam are really tricky, and sometimes TA is not patient to answer questions), but if we put those bad mood aside, overall I think this is a good fundamental course and I learned a lot from it.

My background: Not CS related; 4th course in this program; Entry level python, sql, java. My grade: 90+ for all 4 exams, 95+ for all 3 phase of projects. Time put: avg 15hrs/week Suggestions: Study Hard (both lecture video and textbook and self learning for projects); Go through every piazza posts and ask questions; Fully utilize the project as a full stack practice;

The most recommendation part of this course is the project. Maybe it is a "toy level" from some professional's view, but it is a true full stack project for beginners which can put on your resume. I understand some friends will say it's all about "SQL and stupid PHP". But actually the project's requirement is very flexible and you can use any tools/languages/platforms you want, for example, give you a good change to learn html/css/javascript, flask...etc, which are industry widely used tools.

I never leave reviews on this platform because I am lazy to do so, but this time I make an exception simply because this course is off-the-chart terrible.

Fair to say, the material is not good but FINE with a bunch of outdated material (the same as many other courses). You may not have chance to use them in the industrial world (PS: My background is a software engineer in a non-profit), but you can have some better understanding on some underlying structure (again, still not too deep understanding but you may feel you know something you didn't know before).

Now I am going to say the most essential part of this review, is that you should try AVOID taking this course.

The instructor, head TAs and some other TAs who stay this positions forever, are NASTY human beings I've never seen in life. Speaking of TAs such as Alex, Peter, etc., I am not sure if they are unable to find other jobs so they choose to torture and insult you in a pathetic way.

About the team project, there are 3 phases and each of them partially relies on the feedback from the previous one. We always receive the feedback very late so we lack time to start to do the correction and complete the next. The requirements are sometimes vague. If you try to be clarified, you either receive an unclear answer in a sarcastic way, choose not to answer and mock your questions, or receive different answers from different TAs.

Also, as other review mentioned, the exams are difficult to pass, and too heavily weighted. This course requires some work to be re-structured.

It is totally unacceptable that Georgia Tech makes such a course as one of core courses of Computing Systems specialization so many students have to take it, and it is unbearable they allows many head TAs like these human beings stay.

In a word, if you have better option, please DO NOT take this one.

UPDATE: I can't help noticing there are many positive reviews pouring in all of sudden, cannot believe TAs are trying to make themselves look good by leaving fake reviews. So sad.

I am almost done with the OMSCS program, and I’ve finally hit my limit and needed to vent by leaving a review for this class.

AVOID THIS CLASS!

I was naïve; I read the previous semester reviews and thought, “I’m smarter than all those folks, I’ll do fine”. Well, I’m not as smart as I thought I was -- I should have taken the warnings and avoided this class.

The Good

• The video content of the course was decent. The professor did a good job explaining some of the basics, and the content had good examples that built off each other.
• I lucked out and had a fantastic group. Although the class was a disaster, the group I met will be friends outside of this class.
• The grades were typically returned in a reasonable time frame.

The Bad

• The material is very dated and does not align with modern application development. The project is implemented in a waterfall style, and if you misunderstood a requirement, you would be penalized severely upon the project demo. We were also held to requirements that were not documented in the requirements nor on Piazza, so I guess we need to be mind-readers.
• Many times we needed clarification on a requirement. For example, our group made a private post on Piazza and was told, “that is a design decision”. So, we made a decision and found out they did not like our design decision when we got our grade. Our grade challenge was denied despite trying to clarify the requirement we did not understand.
• There is no mention of NoSQL databases or Big Data concepts within the course. Instead, the class only focuses on Relational databases, which is okay but disappointing for a graduate course.
• Before taking an exam, you must review several legal-type documents about what is not allowed. You feel like a criminal getting chastised when about 5 bullet points would suffice. It is very excessive.
• The class does not use the online grading calculator available in Canvas. The TA’s state it is “easy” to calculate your grades separately because Canvas may be incorrect. Regardless, I would suggest calling Canvas support and figuring out how to use the platform correctly. The TA’s could at least share a Google Sheet with a grade calculator to ensure no mistakes. Seeing your grade seems like a basic expectation of any graduate-level class, especially a technical degree from GA Tech.

The Ugly

• The 4 exams are brutal and worth 50% of your grade. There is a negative grading scale, so you are penalized for incorrect answers on a multi-answer question. For instance, if there are 2 right answers to a question and you select 1 correct and 1 incorrect, you get 0 points. I took a pessimistic approach on the exam, and for Exams 1 and 3, I didn’t have a single wrong answer but failed to mark additional answers and still got a score in the low 90’s.
• More on the exams, there are only 25 questions, each question worth 4 points. So to get an A in the class, you cannot miss more than 20 questions combined on all four exams, even if you got 100% on every other assignment/project. That is a steep penalty for people with test anxiety.
• The language used on the exams is very tricky. It is almost like someone has a grudge, and they are intentionally attempting to fail you. I do not mind a few questions that are extremely difficult to answer, but these were painful. I cannot imagine how a non-native English speaker would pick up on the subtleness of the wording.
• The exam complexities are ridiculous. While the lecture materials were decent, they were also very basic. The book did a decent job, but it depends on how well you grasp the content. While I understand this is a graduate class, the difficulty of the test questions is undoubtedly unfair. The best way to explain it is this analogy. The lecture materials and book teach you how to apply a band-aid correctly, but the exam questions expect you to have the knowledge of a brain surgeon.
• The TA’s in the class are exceptionally rude and unhelpful. The TA’s are in the wrong line of business, and they do not want to teach, they would prefer to belittle. That feels very harsh, but it is accurate and consistent with the other reviews. I am sure there are some kind and helpful TA’s in the class, but my interactions sucked.
• The project is the wrong type of project for this class. You are required to build a complete web application from start to finish. While a relational database backs it, the SQL requirements are basic CRUD operations with a handful of reports. Furthermore, 80% of the work is building a Web Application, none of which is covered in this class. Rather than spend all the time building a web application, we could have used a platform like Tableau to master our SQL skills. The project should be re-imagined, in my opinion.

Overall, my scores on the project phases were in the high 90’s, two of my exams were in the low 90’s, but I’m going to get a B in the class due to two bad exams.

I received an 90+ percent on all exams and a 98 percent on the final project. I eventually got an A, but it took far too much additional effort and time. I am certain that I do not need to go through anything difficult in order to learn something, especially in this class.

Most drawbacks of this course are avoidable. Here are tips.

TAs: Attend the office hours. Leo will answer your questions in person. Search keywords of your questions before you post a new question on piazza first. Otherwise, you will feel being offended. Don't use piazza frequently you will feel TAs are nicer.

Exams: Read textbooks for exam 1 and 4. Watch some other resources that you can find on youtube or somewhere else. These two exams will cover 15-20% of content that is not fully explained in lectures.

Projects: Select your teammates carefully. Freeriders will ruin this course and your life. And due to no useful strategy to report free-rider issues (team evaluation didn't work), you will never get rid of free-riders except you quit or he/she quits.

Team Evaluation: TAs won't open the link for your mistake. If you don't fill the survey you will lose 33.33% POINTS.

The teaching staff is Okay. Pro is that they actively and promptly respond to students' questions Leo will attend the office hours. Cons are that sometimes they have a rude attitude and see students as stupid. "Please read the documents carefully" or "please read the instructions carefully" are not always helpful in answering questions. Or "Don't play this game with me". I don't use piazza actively and just searched for answers for exams. Overall, I'm okay with the instruction team. Andrew Jo is nice to deal with. Thanks, Andrew!

The exam is a pain. Overall, the examinations went well for me. But it still sucks. Exam 1 contains a lot of wordplays, and I see that other reviews have mentioned it in previous semesters as well. So, this problem has been around for years, but it has never been resolved. They could easily edit the question phrasing to make it clearer and less ambiguous, but they choose not to do so because they don't think so and just ignore the fact that students point this issue out term by term. Exams 2 and 3 were okay. Exam 4 is a nightmare. If you want to earn a grade higher than 85%, You must read the textbook thoroughly. About 20% of the exam's content isn't covered in the video, like to prove lossless of BCNF. Exam4's average score is only 62. NO CURVE IN THIS CLASS.

The project is okay but the grading sucks a bit.  You only learned the knowledge of Phase I to finish Phase I, but the TA will assess your deliverables from a God-like perspective.  They will stand from Phase II or Phase III to grade your project. Even if your deliverable passes Phase I standards but may not Phase II or Phase III requirements, they will deduct points and just tell you that your project will not work. How could I know it won't work in later Phases? It's ridiculous. 

The teammate sucks.  It's not the fault of the course, but you can't do much when your team has some free-riders. Even if the free-rider in your team contributes nothing to the project, he or she will receive the same grade as you. The TAs will simply advise you that you can reflect this in the team evaluation, but the team evaluation is completely helpless. However, as long as free-rider completes the team evaluation and grades himself a full score, he won't get a 0. On their overall scores, the penalty is a maximum of TWO POINTS. So, if you want an A, you'll have to spend a LOOOOT of time working on tasks on your own because your teammate won't do anything. Your efforts may be rewarded, but your free-rider partner will also receive an A due to your efforts. IT SUCKS! If you give up the project because of free-rider teammates, you will get a B as them but they don't care. TAs won't help you figure out free-rider issues. The team evaluation does nothing.

It's preferable to have someone who knows front-end (HTML ccs), one or two who understand SQL, and someone who understands PHP. The most crucial element, though, is that there are no free-riders on the team. A responsible beginner is still superior to a seasoned free-rider.

Free-riders just did nothing but still can get the same score on the project because you have to work hard for them. So QUIT IT AS SOON AS POSSIBLE if you find that your teammate is a free-rider.

The head TA is Not Professional! I do appreciate his quick response on piazza, but his tone is annoyingly Ironic! I have been a TA for 6 years, 2 years in my Master and 4 years in my Ph.D. From my basic understanding on TA’s roles, TA is supposed to help students out in a proper and clear way instead of leaving ironical and ambiguous answers on piazza. I do understand none of TAs like being challenged, but I hope DB’s TAs could also learn one thing that have different thinking on exam questions or projects even requesting a regrading are very reasonable and routine things. Please don’t be pissed off or being aggressive!

Although I have some complaints about the TAs, the contents of the lectures are definitely helpful for those having no experience in this field. The group project is a full-stack project, giving you an opportunity to learn php and js. If you want to know more about exams, you may want to gather some ideas from other posts. To be fair, this course has build a solid foundation in database for me. Just not enjoyable!

The head TA is Alex disgusting. The exam4 is so stupidly ornery with average score 62 out of 100. The other 3 exams average are 85 or better. And only like 2 points punishment for overall score for freerider if they do nothing but give themself a high rate in the final project. Meanwhile we already report him for a lot of time. But head TA just say do the team evaluation without making any further intervention or punish the free rider. Don't select this course unless you are a masochist.

STUPID COURSE. YES, IT IS.

The course content is OK (I like this textbook). The database is a new concept to me so I personally learned a lot from the course. However, the course setup is disgusting.

Exam 1 is tricky. A lot of wordplay in exam 1. A lot of concept questions from the textbook. Most of the points I lost were due to the semantics of the question (I am a non-native English speaker).

Exam 2 & 3 are OK. They test your understanding of key concepts in a database which is good. The questions are not too easy and not too difficult.

Exam 4 is very hard. Many questions are from the textbook (not covered in the lectures). I feel like they intentionally created those questions that have trivial textbook concepts just to test if you read the book or not. The mean grade of exam 4 is 60+. If you read and remember the book word by word, you will do great in exam 4.

Team Project. It is a full-stack project. 20% of your time will be spent on the database and 80% of your time will be spent on the non-database part which is ridiculous. This is a database course!!!

TA is extremely rude. Ruder than every single TA/Instructor I have ever seen in my life. I still remember a student asked something like “why this is the correct option for this question?” The answer from TA has four words “Yes, it is correct”. This is disgusting.

My suggestion: if you already know the database, DON’T WASTE YOUR TIME IN THIS COURSE. YOUR LIFE IS SHORT. SPEND TIME WITH YOUR FAMILY. If you know nothing about databases, you have no choice but to take this course as this is the key course in the CS field.

This class sucked. Teaching Assistants (TA's) have serious attitudes. Some say they have to be rude or unprofessional because of the large class size and small patience, but those are not excuses for a university setting. (In fact, other class TA's are not like this and those classes fill to capacity because of demand unlike this database course.)

You won't learn SQL much; seriously, there is one short lecture video series on it. Better off to learn SQL elsewhere. And if you don't know how to program in PHP and HTML, you will find it difficult to contribute to projects and your TA's will track your Github submissions, or lack thereof.

What's more, the tests are not meant to examine your understanding; they are full of tricky questions that have no basis in the lecture videos (maybe there somewhere in the dense textbook readings though).

At any rate, I only picked this class because there were no other ones open for the most part; this class definitely won't fill up to full capacity because of the bad reviews and poor course quality, so DON'T be tempted to take it just because other classes are a full capacity. You have been warned!

Addendum: I got a 77% on Exam #1. I got a 58% on Exam 2. I got a 95% on Exam 3. And I got a 38% on Exam 4.

Another Addendum: The TA's will literally threaten to temporarily suspend you from Piazza if you post a similar question already on Piazza, which will have hundreds if not thousands of posts. That is why I never posted, for fear I would be put down as an moron, publicly scolded or even suspended from Piazza.

This class is ridiculous.

This is my first course in the OMSCS program, and it is the worst course I've ever taken in my life (from BS, MS, and PhD). It is not because of the course itself, however, it is due the professor and STUPID TA's. Many times, they didn't have much patience or any respect to the students. I want to say they are RUDE. Feeling that they are not helping students to learn the important parts of database, but instead they are trying to test if you have read everything in the textbook. Regarding the project, it really is not much about database design, or SQL. I spent much of time on PHP, which should not be in this course. The project spec is not clear, they can be different ways of understanding of it. However, the TA's asked your to exacly follow what they are thinking about it. They were very strict on the grading. Please avoid this course if you don't have to take it!!!

The course is very bad. The database is a very important component in computer science. However, the instructions and lectures of this class is so messed up. The professor like to play word game like how you understand “may” or “might” in the exams. The lecture isn’t good and lots of concepts are not covered in the lecture videos. The lecture videos are not very clear. I don’t suggest people taking this class as this is kind of waste time. I got pretty good grade on this Course however, I still don’t recommend it. The TAs of this course are amazing idiots too. They don't specify the project requirements very well. You have to ask in piazza.

BACKGROUD: math and finance background, learned OOP in school, worked as TPM in a data team at a financial company so very familiar with SQL.

TIMELINE AND TIME SPENT: This is my first class at OMSCS, I also started a new job at the same time. But with a strong project team, I found this course manageable. The course has 4 exams, 3 project phases for 1 project.

REVIEW: Overall, I liked this course despite lots of people complaining about TA. The course's structure is intuitive and together with the project, you apply what you learn into the actual work. 12.5% for each exams, and 10%,10%,15% for each project phase. So the weights are pretty even, and you would not have too much pressure for a specific one.

Project -- However, the project is not simply about SQL, it also requires skillsets to accomplish front-end and back-end design for an application. Luckily I have a strong project team so this part wasn't a challenge.

Exams -- The first exam is hard as you need to build on the concepts around this course so it takes time to kick in. But the ones after are relatively easy. (haven't taken the final one yet when this review is done)

Content -- I hope they would have more instructions on the linkage of project and textbook's concepts. There are times that we have to try and guess some implementation methods. So that was a bit struggle.

Overall as I said, would be a good class for semesters where you don't have a lot of time to study. I like this course.

I agree that the reviews for this class are accurate. The tests are very difficult to pass and are too heavily weighted. This class needs some major grade restructuring. It is not a fair assessment on ability or study habits if you are just throwing tricky wording into a test. I found myself second guessing my answers and losing points on tests because of how questions were written. There is no curve or extra credit. You get some free points for completing the team surveys, but that is not enough to negate a very bad test score, which unless you have taken something like this before or have worked in database design, you will absolutely get. You should not take this class without prior knowledge of EER diagrams or database design. The lectures are very short, and you are relying mostly on the book. You will get examples on the test that are just very briefly discussed in lectures and are much more complicated that what is discussed in the lectures. While the tests are open note, your open notes are useless without either prior knowledge or a deep understanding of database design. This wouldn’t be an issue if the tests weren’t so heavily weighted. The only good thing I can say about the class is the TA’s are quick to respond and nice, but overall nobody seems to think this class needs restructuring despite low class average tests scores.

All of the previous reviews describing the tests are completely accurate. Each question on the exam is worth on average 4 points, and it's too easy to miss the question unless you are extremely careful (with the grammar, not the concept). The lectures are teaching you certain concepts, but the exams are testing you on other skills.

The group project is pointless. It is a contrived design exercise, but all groups are given the same specifications and instructions. There is no reason why the same deliverables and content could not have been spaced over multiple individual assignments. IF YOU GET A SLACKER GROUP, it will be as if you are doing the project as an individual assignment, anyway... because in the end you have to review all sections and correct others' mistakes. The grading is brutal, and as soon as Phase 1 grades were released, there was a post on piazza about the regrade process, and extremely detailed steps and guidelines for the regrade. If there is such an expectation for a high number of regrade requests, MAYBE something is wrong with the assignment and the clarity, and/or the rubric.

Also. The course material is extremely dated. Only relational databases are covered in any depth, and significant time is spent on topics such as Entity-Relation models and Enhanced-Entity-Relation models. I do not expect to use this material outside of this class.

NOSQL, non-relational databases, distributed databases, and important topics such as master-slave database scaling and resiliency, clustering, performance, and DB hashing are not covered or barely referenced in passing. If you have taken any sort of introduction or undergrad DB class, steer clear, as this class will be a complete waste of your time.

I should have listened to the many MANY reviews that warn against this class' exams. I had to withdraw. English is my second language, but I consider myself very fluent. However, the wording in those exams have no learning or academic intentions WHATSOEVER. The main purpose is to confuse you, so you can fail. It's a simple as that. Class has a very interesting content, and lessons are good, and the teaching staff is very nice too. Group project seemed doable as well, but the main weight is toward this terrible-worded exams.

good: I dont have background in either CS or database. This is just my 2nd course. I learned a lot from this class. It covers most of the database basics and sql. I was able to do all sql online challenges from interviews just using what I have learned from this class.

bad: the grade will not be curved. for exams, each choices are 4 points. With that being said, you can easily lose 4 or 8 or 12 points, and it is hard to get a high score. You have to be really careful about the exam. Ended up with a B

Doing this in summer was challenging. Exams are hard and carry substantial weightage.

If you don't know about database, you can learn a lot from this course. However, do not depend on only textbook and videos, they are not helpful on exams. Actually, it feels like the textbook is trying to keep you get more and more confused, I never feel it helpful at all. You must look at other resources. The first and second exams are okay. but the last exam is really difficult. The medium grade is only 65 and no curve. I like the TAs and Lecturer, they are very kind.

Lecture videos are very good, excellent, exams are kind of difficult, project phase 3 need someone who knows the front end.

The way the course is designed is to set minimum efforts from teachers and assistance . Small old videos with few topics with very few explanation. No chance of going back , if you miss any deadline . Videos are super easy and short. No need to read book . Just take notes while you watch the videos and keep those handy while doing exam . The exams are super hard . The teach you abc and ask full poem in the tests . But if you read vigilantly and answer vigilantly you can definitely score good. Project is again difficult and require good amount of team collaboration. It is very difficult to score A but I was able to get B even getting 66% on my first test that I gave without studying because I knew all the DBMS concepts . You can manage this course with any other course too but remember dont expect anything more than B. Good luck

What this class will cover:

• Database concepts (like the name suggests), mainly regarding how relations are created and mapped, moving from data entities into a entity relationship model, and then converting that model into a database
• Project focusing on database implementation (tech stack of your choice)
• Database storage concepts (mainly with disk storage) and normal forms

This isn't your simple undergrad class that you just need an understanding of SQL and joins to pass without much effort. There are concepts that are rather vague and will require you to pay at least some attention to lectures, textbook, and practice exam.

Exams are worded somewhat tricky but as long as you actually read the material and take the practice exams it's not too difficult to get As/Bs. Textbook is pretty dry (it's databases, what do you expect), so took me a few re-reads of chapters to internalize things.

Exam is open note but don't let that lull you into slacking on studying. I honestly procrastinated studying for every exam and left every exam knowing I could've gotten a higher mark if I actually bothered to spread out my study schedule.

Find a good project group! Make sure people in your group can commit to meeting at times/days and are communicative enough to advertise conflicts well in advance, otherwise you will get burned.

Probably not the greatest class to take over the summer but most of the class managed to get an A/B so not the hardest class either. TAs and Prof are alright, TAs are just tired of dumb questions it seems.

This is a very strong course overall. The TAs are great and Dr. Mark is present at all office hours and active on Piazza. Questions are answered at a rate I simply don't understand. I really appreciated the work and help from the TAs.

The project quickly becomes the central focus of the course and you should not procrastinate. Start early and pepper the TAs with as many questions and clarifications as you need. Our spontaneous questions saved my group a lot of wasted time running in the wrong directions with incorrect assumptions or understandings of the specs.

The exams can be tricky but perfectly passable if you know the lectures and read the text. The text is important in this class. There are exams questions that come from the text for sure. But making an A to a B on every exam is perfectly doable.

As most people said, watch the lectures, read the textbook, and watch the office hours videos. I got an A in the class doing this. The concepts were not challenging, but you need to pay attention to detail as the wording is super important on exams. And honestly, as someone who deals with database designing at work, I believe that attention to detail is important.

As for the technology used in the class, it is a bit outdated as they suggest creating a simple app from PHP for your final project to access the database. My team ended up creating an app in Node and React. We did well and got mid to high 90s on each phase of the project.

I really appreciated the staff for this course. The professor and TAs do care about students understanding and doing well in the class.

This class is not as bad as people say. But i think what will determine whether you do good in this class or not is very obvious:

Do you actually study for exams? Most of the grade (50%) comes from exams alones. They are not hard, but can be sometimes a little bit tricky in the sense that the questions really try to pick your brain with corner cases. Sometimes questions are poorly worded or confusing to read. You also have to actually study for the exams. This is not a class where you can just not study and ace them, unless you are a 50 year old system administrator or something. Be sure to take notes for both the lectures and the book. Also be sure to attend most office hours and read most/all piazza posts, as the TAs will give great explanations for pretty much everything.

Do you have experience with SQL? This class does a pretty poor job teaching you to write SQL code because there are no weekly assignments/exercies. The class only shows you a couple of videos about it and thats it. It is pretty much up to you to learn it by yourself. It is important to know SQL and have some experience with it because one of the exams is just about this. The projects, although easy, do require you to write some moderately good SQL code in order to do well in them. Good news is that if you get a good team this should be pretty easy to do.

Thats it. I saw people struggle with this class, and it mainly came down to doing poorly in these two previous points.

In terms of the class itself, it is a little antiquated, but you still get to learn some fundamental and critical concepts of databases, such as EER diagrams, functional dependencies, indexing, and normalization, all of which are still relevant today. My favorite part about this class was the professor and TAs. I have never seen more responsive TAs in any class. Your piazza questions will get answered in at most 10 minutes after you post them. The professor is also super nice and funny, with a cool danish accent. He has cool grandpa vibes.

"I don't know why this class gets so much hate on OMSCentral" - what is there not to know ? Exams are 50% of the weightage with ridiculous multiple choice answers and negative marking with each question being 4 points. Several reviews have said this and its a justifiable hate.

I got an A on another course and I can confidently say that this course is not reflective on your technical ability. If you're good in reading, you have a keen eye and you don't overthink, you'll do well else you'll end up with a C grade.

Inability of some people to understand how this course gets hate is just as ridiculous as the multiple choice exams here.

I don't know why this class gets so much hate on OMSCentral. I found the experience enjoyable on the whole and learned a ton about databases, especially via the group project. Don't take this course if you've taken a databases class before, I doubt you'd learn much that is new.

If you have not taken a DB class before, go into it with reasonable expectations and I think it'll be an enjoyable experience. I marked "Medium" difficulty as a lot of the concepts were new for me (esp. relational algebra, calculus, and normal forms) and took some time to get up to speed.

Rather than repeating things that have been said before, I'll try to make my review based off what others have previous said:

Pain points from prior reviews that I DID NOT find to be true

• Leo & the TAs are extremely explicit that words matter a ton for his exams. This means that you should nail down definitions that include "may", "must", "many", "all", "some", "more than 0", "more than 1", etc. well in advance of the exam. This is most applicable to Exam 1. All exams are open note with no page limit, so the more examples and practice you can do, the better off you'll be. Exams 3 & 4 rely much more on practice problems, and are not so much based on reading comprehension.
• Same goes for the project, they were very clear about what grades were based on, including for the Phase 3 demo.
• I got lucky and formed a strong team very early. Everyone was proactive and engaged. I sense this is an exception within OMSCS.

Pain points from prior reviews that DID find to be true

• Many OMSCS exams seem to only have 20-25 questions, meaning each question is worth 4-5% of the exam grade. I don't know if professors will ever improve this. It's definitely frustrating.
• The full data for the project is posted on the Friday before the code submission deadline on Monday. Too short of a turnaround time -- you'll be working most of the weekend on troubleshooting new bugs in your application.
• Make sure to stay on top of Piazza, reviewing it every day or every couple of days at most. TAs sometimes post valuable information in there that will matter to your project or the exams.

All in all, I thought this was a good experience, and the bad rap it gets on OMSCentral is relatively unjustified.

Barely did a thing for this class and scraped by with a 90. Watch the videos ahead of time and take detailed notes on the textbook and you should be fine. Crib sheets are unlimited which was helpful, although not much of this class dealt with memorization. Project was fine; don't reinvent the wheel or bring in anything that's not absolutely necessary, just find an easy framework and phase 3 should take 10ish hours. Since the course content wasn't too difficult, difficulty was introduced through unclear grading criteria for the project and very specifically worded exam questions -- will probably be difficult if you're a non-native English speaker. Oh, and don't ask dumb questions on Piazza or the TAs will (rightfully so) get snappy with you.

Ask anyone who has taken this course, and what they hate about this course, and exams would be on the top of the list. 50% grade for exams in unheard of in any course I have taken so far. couple that with multiple choice (more than one answer ) questions is what makes this course a very bad experience. The questions are framed poorly, for a non native English speaker sometimes this creates a confusion like in my case. I have close to 12 years of experience in DB systems and ended up with a B (missed A by a whisker) .

My two cents for the course, only answer what you know from the options so that you at least get a partial point on the question (marking an extra option which is a wrong answer will give you a zero) . Read the questions thoroughly till the end (dont miss reading an order by which will cost you). Notes are allowed, make good use of it. skim through the text book if not thoroughly so that you can take bullet points as notes.

Grading for the projects has been fair and piazza was very helpful to clear questions. the only downside were the exams

Exams: The first exam has some confusing wording issues, but the second and third ones were not as bad. Granted the first exam was more definition-based, whereas the following two were more conceptual. Still, the exams are weighted too high; I feel that 30 - 40% is more reasonable.

Project: I took the advice of past reviewers and put the effort into finding a good team. My team had different strengths, but similar weaknesses. That’s part of the reason why we didn’t perform as well as we would have liked in phases 2 and 3. Nevertheless, I feel that the instructional team could have been a lot more supportive. The TA who reviewed our Phase 1 didn’t give us the most detailed feedback, so we got screwed over on our Phase 2 grade (which was graded by Alex).

Instructional Team: The TAs that have attended OHs are very nice and Alex answers all of our questions super quickly. However, the lectures, while informative, are sometimes cringey (I’ve wanted to slam my laptop shut). Yeah, I do find the behavior of the head instructional team to sometimes be off putting.

Value: I had some database experience in the past, but not a super solid foundation. So I felt that my background knowledge helped me, but that I also learned a lot and became more confident as a coder from this class. I would not recommend it to people who are more experienced in this area (unless you want an easy A).

I did not take the reviews on this page seriously before signing up, and I wished I did. I will preface this by saying that I have prior experience working with SQL and Python so this class wasn't particularly challenging for me, but I still found it very annoying. The material uses a lot of very outdated technology, you'll still learn generally useful concepts but I definitely wished they taught some more modern stuff.

The project is your only assignment, and it's fairly easy if you have a good team. Problem is grading on this is so vague, I feel that most of the points we missed on the project was because of a misunderstanding or lack of clarification in the project spec or even the grader having different opinions than we do/not understanding our code. For example, we had COUNT(*) in a SQL query and lost points because the TA wanted us to count an arbitrary attribute rather than using *. The fact that they expect you to build out database schema without any example data I also found very annoying. In my view, I don't understand why there wasn't example data provided, if that were done they could grade us objectively based on whether or not we return the correct results rather than hoping a TA can read and understand what our code does correctly. Even on Piazza questions they recommend "not using weird things" so the TA can understand your code. Like what?? How am I suppose to know what the TA is familiar with? How is it my problem if they're not familiar with certain packages/SQL dialects? If you let people use whatever they want, how is it fair to dock them points if they happen to use something you're not familiar with?

Feedback on the project is also incredibly slow, probably because they're making TAs read everyone's code and try to decipher what it does rather than using some objective measure. For example our project phase 3 is due in 4 days, and we're supposed to use TA feedback from phase 2 to decide how to proceed. And despite phase 2 being submitted over 2 weeks ago, we've still yet to receive feedback on it. So how do we make sure that we're implementing all the TA feedback if we don't have it??

The exams are multiple choice, and are generally not difficult especially since you are allowed to upload and refer to your notes. The SQL exam was my favorite because it felt like the only one that wasn't just "can you decipher semantics and notation of the instructor correctly". Many of the exams felt more like SAT reading questions than anything else, so if you're not fluent in English I'd stay away.

In general I'd say I did learn some things and I'll probably be scraping by with barely an A. But I feel the design of the course was not as good was it could've been and I would've appreciated more coverage of practical topics with modern implementations. Honestly if you have basic knowledge of SQL, the things you'll learn here are pretty limited. I would expect a database course in 2021 to talk about things like Postgres, NoSQL, even some ORM stuff etc. instead of recommending a WAMP stack. The assignments and exams were also poorly designed and graded in my opinion.

This class has a fairly low workload, especially if you have a good team. I think I did about 80% of the project work myself and I still only spent a few hours a week on it.

This course is essentially identical to CS-4400, which I took as an undergraduate a long time ago, so I'm not sure why or how it got approved to be an OMSCS course.

The exams are definitely tricky. The wording on a lot of them is complete nonsense, and when students try to make a case for why the answers were confusing the TAs basically just call them stupid and ignore them.

If you're not very fluent in English, I'd recommend skipping this course, as you'll probably have trouble with the exams. Otherwise this course is a pretty easy A

I eventually did well in the class and I actually liked a lot of what I learned in the class.

I did see a lot of students do poorly in the class, and I don’t think it was their fault (see challenges section below).

Practical tips to do well in the class are:

1. GO TO THE STUDENT HOURS (the professor helped narrow down what is on test in these sessions), this will save you hours of time, knowing where to read and so on to prepare for tests.

(I would say, attending student hours is one of the tricks of this class that I learned nearly too late).

2. Read, read, read, read, every word of the text and learn it as best you can, obscure details are on the test.

3. Watch the lectures again, and again, and again and learn them as best as you can.

4. Practice the practice exams again and again and again.

5. Reach out to TA’s I think the TA’s were actually very cool, despite what the reviews below say.

6. Be prepared to do projects on own prepare for a low quality group, 3 of our members really didn’t do squat.

At best try to seek out at least one other responsible and hard working student, you’ll need at least this to do well, it’s a matter of how much time is put into the project really, not smarts per se.

If you get a slacker group, which is probable to happen, be prepared to reach out and let the TA’s know so they can pair you with a good student.

7. Spend hours of work on projects to learn and do well.

8. Prepare to do last project presentation well.

9. Make sure you get all project requirements done, read, and read again to find surprises and ask TA’s questions on message board / piazza.

Challenges:

This course is certainly challenging and I would even say can easily be unfair.

I found the exams elusive hard to cover and learn all material.

I found the exam questions to be tricky.

The exams are fifty percent of the total grade.

Each fraction of a point on exams counts severely towards your final grade, beware.

I found the timing of feedback of project 1 (things we needed to change) and the consequent loss of points on project two to be a bit ridiculous.

The feedback in which we lost ~10 points for was not given until the last minute.

There, virtually, was no way for us to incorporate this feedback given the late feedback, just two days before our project two was due, as the feedback required us to uproot a table on our diagram that would require an extensive overhaul of every contingent piece of assignment that we were to turn in and had already agreed on as a group.

Also the project1 feedback read "Suggestion change table on diagram".

Project 2 we lost points for "Not following suggestion, we should have followed suggestion".

Which begs the question "Are suggestions mandatory? Is there such thing as a 'mandatory suggestion' that is not a contradiction? Or is a 'mandatory suggestion' a type of paradox?

For we chose not to follow the suggestion, as we had no time, and literally interpreted suggestion to mean 'a suggestion' not 'a demand' and mentioned this and lost 10 points for 'must have done / should have done suggestion'.

Things to keep in mind:

• If you do not do well in the class, this class does not define you, as I think this class can be warped in a lot of ways. (Get back on the saddle and do not think that you're inferior / deficient, build new strategizes to do well in this class, next time you take this class, and for future classes).

• Often classes, no matter which class, (classes in general) can be warped, unfair, poorly design in various ways, and taking such can be dismal, painful, and extremely frustrating, I am no expert, yet I am learning how to adapt to such classes, yet failing from time to time, so easier said than done.

• If I am not mistaken this class does seem to make or break students in large groups, to thin the herd as it were, for the tricky exams weight 50% of entire grade, in my opinion they should weigh at most 20%. My opinion is that this class is allowed to exist knowing that it is a kind of weed out course. If so, to my mind, this is a kind of brutal and unjust sorting of students. Sure we want top Georgia Tech graduates, yet such sorting based on the warped parts of the class, is weeding out hardworking world-class students. And such sorting out militates against actual learning and elegant education. Again this is my opinion and I could be mistaken, yet the warped parts of the class, and the many bright and hardworking people I saw do poorly makes me wonder.

• In the end the grading and class can be really fair, it just requires extreme hard work and following the practical steps above (see practical steps).

• Looking back with rose color glasses, I really did like this class and I actually learned a whole lot.

I put I disliked this class, not because I dislike this class, I put dislike, for I remember how much I disliked taking the class while in it, as the make or break 50% of the grade based on exams was VERY stressful / traumatizing.

Yet truly and paradoxically: looking back I did enjoy this class, ambivalence.

Take this course if you want a warning on your status for missing B grade by less than 1%. 50% weightage for multiple choice exams, 1 wrong answer and 4 points gone. I don't understand how this curriculum structure was approved by the dean.

I did not like this course. Its an easy course intentionally made difficult with reading comprehension style exams. Multiple choice questions have answers with many meanings making you choose the wrong one as you interpret it different. Exams are 50% causing a huge drop in final grade due to this. If you are okay being in academic probation cause this reason then this is the course for you. Don't think that it will be okay and choose this course like I did. Some withdrew from the course after a low exam 1 score and its a waste of money investing in this course. I did well in the exams where my actual technical knowledge was assessed but suffered in exam 1 which had such ridiculous multiple choice questions.

Stay away from this course.

This is my first semester in OMSCS program. As a non-CS major student, I was expecting to learn more fundamental knowledge from this course. NOT looking for a course that TA just give tricky linguistic questions in the exam. Some summary for this course:

• Overall, the lecture and videos are good.
• Exams can be really ridiculous, very unfriendly for non-English speaker. I still remember one question about using "may" and "might" mean totally different meanings, seriously? This is a question for CS courses?
• For exams, do spend some time on sample exams.
• No curve for exams.
• Project need some teamwork and time, but not difficult.

This was my first course in GATECH and I do not think this a Masters level course. If you have basic SQL knowledge, you may not learn much in the course. The exam questions are sometimes ambiguous and instructors/TAs know when to ignore the student's comments. Otherwise they are very responsive.

Overall, it was an easy course and marking (specially in projects) is very lenient.

This class is based on the textbook, which is the undergrad database textbook. There is an undergrad database class at GT called CS4400. I guess CS6400 is basically the same as CS4400.

Exams are a little tricky, but I did quite well on them. I scored 89.3, 96, 87.5, 100 on Exam 1,2,3,4 respectively. I just spent a few hours skimming the textbook before each exam actually. Maybe I am just naturally good at such kind of exams.

Lectures are concise and well-made.

Prof. Leo Mark participated in every Office Hour.

TA Alex responded in Piazza very timely. His average response time is 3 minutes. Incredible.

This is my first class in the OMSCS program. I have 10+ years of software development experience. I took this course thinking it will be a good entry into the program. However, it was not a good idea.

We were somehow given a poor grade on the first phase of the project. But TA's comments were bunch of one-liner with very vague information. We've tried numerous times to get any clear answers but were ghosted. It's still a mystery.

Exams are tough because how tricky they are as others have commented. Make sure to read the questions over and over again! Mistakes are very costly on the exams because each question can worth 5% of your exam grade. The lectures are short and good but they do not prepare you for the exams and you must read the book to get an A.

Alex is most reponsive on piazza but can be condescending. Other TAs are non-existent.

I highly recommend to avoid this course.

First course and my first C (from calculation) - great. Had a project partner who did not sufficiently do his part for a phase leading to this. Your performance on not completing even simple tasks affects the group score. Some people should not be in academia if they do not know how to collaborate and work with people. Its remarkable how such people even get employed for software engineering roles. Deeply regret giving the person a good rating as it might have helped him get a good grade and it was not reciprocal. Never again.

Exam structure, bad - Play on words rather than technical knowledge. Put a lot of effort studying for exams only for the right answers to be invalidated by tricky and unnecessarily confusing wrong answers.

Highly advise against taking this course. Thought this was a good entry course to take for OMSCS, sadly mistaken. Don't waste your time and money. Exams are unforgiving, are meant to trick you, and the TA's are very rough. You're better off just taking a udemy/coursera course or watching YouTube videos on SQL.

Overall: Decent amount of work for the group project, make sure you get a good group otherwise this will be dreadful. Exams were tough, I found them tricky and the questions were annoying. The content seemed dragged on at the end (esp with exam 4). Grade turn around was a negative trait for this course, didn’t get the project phase grades a few days before the next phase was due, mind you they built on top of each other.

THE EXAMS... the downfall of this course by far. Unnecessarily vague wording in the questions and the answer options. READ THE BOOK, I made this mistake on the first exam. The lectures are great, nice and short. Prof. Leo teaches well, breaking the concepts down and giving examples to follow along with. However, if you don’t read the book the exam questions will come out of nowhere. Read the footnotes, answer the summary questions, understand the book examples.

The workload depends on how well your team works together but reading the book takes up the other half of your weekly hours spent.

I got a D in this class for a fraction of a point. Seriously, just avoid this class and take anything else; it is so not worth it.

This really could have been one of the best courses in the program, but with it's current structure it has been my least favorite, and I have taken 8 courses so far. It's the exams. We are computer scientists, not linguistics majors! Being tricky, just to be tricky, is not a good way to teach anything. All it does is frustrate the hell out of the poor imbeciles that take this course because all the other courses were already full.

Everyone who will take this course, will only take it because it's one of the last courses to get filled up. Coincidence? No, everyone knows this course sucks; but it doesn't have to. Just take out two courses and have another project in it's place. More work on our side, but we could get a decent grade, practice what we are learning and actually feel like the time and effort we put in, mattered.

The course takes 50% from the exams; and trust me you won't be prepared for them no matter you do. They are just so randomly worded, this is a CS course? This is not a good way to teach. The professor says several times in the lectures: "I believe in learning by doing". Then make us do another project and we can show that we have learned. Tricky tests just degrade the entire experience.

Many people commented the same thing: don't take this course. I wish I had listened.

I disagree with this review https://omscentral.com/review/-MNscmnTrVGQr8LvzfQj saying it should not be graduate level course. We understand you're a genius and know every front-end/back-end framework that you learn in bootcamps. Its not the same for everyone. Adjusting the course projects according to this review makes it a difficult experience though I agree with the exam style.

I just wrote a long and thorough review, but by clicking "submit" it was lost due to some problems of my browser or the website. I don't want to write it again, so I just iterate some key points:

This class is introductory, foundational, fundamental, and undergrad-level. If you already learned about database systems and would like to learn advanced topics, please don't take this class!

It is suitable for students like me who have no undergrad coursework background in database.

My original purpose of taking OMSCS is just to make up for my missing undergrad CS background, so I love undergrad foundational classes.

After taking this class, I feel I have a much better understanding of relational database systems.

Many people don't like the exams because some questions are tricky, but I don't mind getting a bit lower score. Considering the project is mostly scored very high, most of the students would get "A" too easily if not deliberately raising the difficulty of the exams.

The problem with the course is that it is unnecessarily difficult. Exam 1 had questions on theory that tends to confuse you to choose the wrong answer with confusing terms which is not reflective of the concepts used on day to day work. The confusing terms lead me to choose wrong answers along with the right ones leading to a terrible score for Exam 1 despite putting a lot of effort. Exam 3 had some questions on logic briefly mentioned on piazza which can be easily missed unless you spend time to remember all the briefly mentioned points on the 200+ piazza posts.

This course is just not worth the time spent as very simple mistakes can cause you to get a low grade. Though the topics are good, the poor exam style will cause me to get a C grade and I will not be able to meet the foundational requirement.

Unfortunately, I cannot recommend the course due to the reasons mentioned above.

** Unlike a few other reviews have mentioned, projects are 35% of the final grade and the exams are 50% of the grade. Doing poorly on the exams have a greater impact on the final score even if the projects are "easy". Prior experience working on SQL statements and forming study groups also gives you an advantage. You can now decide to take the course, if its in your favor.

The course materials were out dated and I do not write SQL commands as the instructor does in his lecture videos. The instructor team kept modifying requirements throughout the semester. Some of the TAs were really awful. The project was durable but not interesting.

I dropped this course during Phase II registration and switched to another course because as a three-year experienced developer, I've already known most content of the course. However, I've watched all lecture videos before I dropped. So my comments are related to the lecture content ONLY.

The lectures are very good for people who don't know relational database at all. Leo always used proper metaphors to make you understand the abstract concepts. For example, he used the phonebook to illustrate how binary search and B-tree works with DB indices. However, if you already know SQL, there is not too much new knowledge in the lecture you can learn.

Another thing to note. Although the course name contains words "Database" and "Design", you are not gonna design and build a database from scratch. The course is more about how to design data models and SQLs using an existing database system to implement an LAMP web application based on the software specification. Therefore, I feel this course is more like "how to design software application using database". If you are looking for a course to learn how to build a database system from scratch, this course is probably not the one you want!

I review this class based on my expectation of a master's program class. I will review 6400 Summer 2020 with three parts: lectures, exams, and projects.

Lectures: The best part of these classes is the first two-third of the videos. I like professor Mark's sense of humor, but the last third of the videos couldn't meet up the standard of the first two-thirds. The focus and examples between the videos and the textbooks did not meet my expectation to help me learning. Overall, I had my worst experience taking this class as a summer condense one. A student who does not have an undergrad CS degree can still learn the basic stuff if the student does not mind some veteran TAs treat you like an undergrad student.

Exams: The TA designed the class exams to be overkilled, being faired on the exams instead of helping you to learn. The Summer 2020 exams allowed to bring in 6-7 pages of pdf notes. The exam questions were designed to make the notes not useful but testing if the students got some concepts flawlessly. The punishment forgot or confused with certain concepts were got many questions wrong. Basically, the exams were to detect the 'A' student and the 'F' student well but bucket B and C students badly (you can totally get a C with a B+ effort or a B with a C- effort). If you want to feel what 5% of some tricky videos and book materials you think not important becoming 20% of the exam materials; take this class to experience it.

Projects: The overall project of doing an interactive webpage was good. Unfortunately, the TA wrote the project like a non-technical business owner (customer) would write it. Then the TA argued the "customer is always right" nonsense for a database design class. The TA answered Piazza promptly (thank you!). Still, the TA did not admit bad project written materials but continued to argue with students and guarded some essential requirements interpretation like top secrets. In the end, the demo was graded purely on the correct interpretation of the project requirements; and most of the points had nothing to do with database designs and queries but UI/UX. The student grade could reflect on how well the team sends private messages to TA for clarifications.

I made the mistake of choosing this class because I was interested to learn how databases worked. I realized very quickly that the information I needed could have been covered in a 4 hour Udemy and would have been more relevant.

This class features antagonistic TA's that will accuse you of attempting to cheat when you ask a question, extremely poorly written assignments that you will be graded on subjectively and with no clear rationale why points are being deducted, very tricky exam questions on material that is not covered in the lecture or the book, and an extremely poorly structured project assignment. Expectations are that any deviations from the poorly written instructions will result in point deductions. Any mistakes made by the TA's or Professor that impact your work are met with a shrug of the shoulders even if they are significant and result in wasted time for the students.

I can simply say that the format, content, and delivery method for this class really DEVALUES what the OMSA & OMSCS program should be all about and I wouldnt recommend anyone in the program waste their time taking it.

I work as a data analyst so I found this course being too fundamental except for the final projects. However, the first 2 phases of projects are easy to get points off and the TAs are not helpful, as a result it is not easy to get A.

I took this course in summer 2020, and I get A finally. But I really don't like this course. My background is a researcher in machine learning field, and I am not an English native speaker.

First, you're required to purchase a textbook. Not an online version. In summer 2020, prof considers the COVID-19 conditions so we cannot open the book in the exam. But the exam is open-note. I see many people complain that the prof requires a paper copy textbook, and I am fine with that. I don't buy it because it takes about $200. But you need to spend a lot of time on that book, because some contents on the book (which are never mentioned in the lecture) will be tested. So be prepare to read that super long textbook.

Second, the workload is not that bad on average. For me, I only listen to the lecture before the exams, so the most time consuming part is the project. Finding the good team is a key and phrase 3 takes me a lot of time, because you need to develop a webpage. I feel like I spend about 40+ hours on those two weeks for project phrase 3.

Also, if English is not your native language, be prepared to be confused for exams, questions, lectures everything. Some words are very tricky and you may lose points because of misunderstanding.

The exam is not hard, but it is difficult to get a very good grade. So be prepared. You will have multiple choices for the exam, but you don't know how many choices should have. So you may like me spend 10 mins looking at the question, and hesitating if this question should have 2 correct answers or 3.

The professor is good, while some lectures need to be more explained. (I usually need to watch twice to make sure I understand every words. Detail is the key to success in this course) Sometimes TA team makes you feel uncomfortable, which is true. But I still want to thank Alex. Can you believe the average response time for Alex is 4 minutes? If you take this course, don't be shy to ask. If you are not sure the answer, ask it loud. If you don't understand the super complicated rule, ask it. Ask loud may be another key to survive in this course.

To be honest, I don't think I learn anything useful related to database, but the project helps me become a little expert on HTML, JavaScript for webpage development.

Explains well the DB concept and Design. Really good hands on projects to get exposure what it take to translate and implement business requirement to a working database with UI application

The professor and the ta's are very good and the course context is also ok. This course will not teach you anything new, only thing I liked was the Efficiency and Indexing part which teached or refreshes knowledge about some core disk i/o concepts and calculations. Overall, don't take this course if you want to learn something new.

This was my second course in this program, and I really liked it. TAs were helpful and Leo's videos were very useful. The course helped me to understand the foundations of database design, analysis and implementation. I, personally, have no negative experience with this course.

I track my time closely. The whole class took me 51hrs and 45 minutes. So that's just over 4 and a half hours a week. (This was a summer semester, so in fall it would have been closer to 3 hours per week)

This is an easy class to get a B in. I did not buy (or download) the book. So my B was just from watching the lectures and doing the project. If you want an A, I would recommend getting the textbook. The only other recommendation I have is to get on a good team as early as possible. You are allowed to pick your own team. The project is very easy if you have a strong team. Its just a simple CRUD app. The project will be hard if you don’t have any full time developers on your team. You can pick any tech stack you want so that’s nice.

Overall, I did not like this class. I would only recommend it if you are looking for an easy class, or if you do not work as a dev already.

I would not recommend this class. The course content was fine and required about a medium level of effort but I wouldn't recommend mostly because of the professors and TAs. They are rude, condescending, and will actively tell you they care more about their insanely intricate rules than learning the material which really takes away from learning. They literally mute conversations in the forums for weeks at a time and refuse to answer questions during exam and project times to what amounts to about 40% of the class time (conversations were disallowed about 5 weeks out of the 11 week summer semester). In addition, you have to re-read several pages worth of exam rules before every exam.

The course content seems a bit out-dated and there's a huge focus on underlying database theory. I found there was not enough lecture material to cover the sometimes very in depth theory questions on the exams so reading the textbook is a must. Otherwise, it was interesting to learn database theory and couple it with some SQL and overall information on database management systems. For being so focused on students following rules, I found more than usual typos and errors on lectures and exams which again, the TA's and professors refused to change or accommodate.

Group projects are always a joke and this one was no exception, although I was lucky and got a pretty good group. Again, the focus seemed to be more on following their rules than demonstrating you learned anything. The final phase takes a lot of effort and should be started as early as possible.

it feels like this database course was designed 10 years ago. You learn the basics of data modeling, relational databases, and use some SQL. There is hardly any mention of NoSQL, which was disappointing. I also wish they spent focus on writing SQL because of how many jobs are looking for it. The concepts learned were useful, but the homework felt very subjective because the teacher did not teach the concepts well enough. The worst part were the weird expectations in the group project. The database aspect was perfect, but the project required us to design the front end of the application that connected to the backend database. The front-end code was almost entirely written by one person on our team of four. It was an unrealistic requirement for a DB class. I don't know the first thing about front-end development.

I would NOT recommend taking this course and would highly recommend taking other courses instead of this course if you are looking to get a bang for your buck. The material covered was not taught properly and are out-dated. You will NOT find a use of anything taught in this course in your career. You are better off NOT taking the course and learning everything taught in this course yourself instead of wasting you (or your employer's) hard earned money on it. I believe students owe it to their employers to take courses that add value to each of their organizations and Georgia Tech owes it to both the students and companies to offer material that is relevant in this age.

Before I took this class, I was very hesitated. On one side, there are so many negative reviews for this course during the past. On the other side, I know this course is a very important foundation course especially to those come from non-cs background like me. Finally, I decided to give it a try with very low expectation. However, it turned out pretty good and was way over my expectation.

Several points to mention here are as following:

1. Watch the lectures. Leo did a very good job on the lecture videos and those lectures are very clear, concise and easy to understand. Most of the exam questions are based on the lectures. So make sure you watch them.

2. However, if you are aiming to get an A on this course, you definitely need to read the textbook as well. My suggestion is to watch the lecture once, then read the textbook and take some notes for those are not covered by the lectures. Even though the exam is open book, you don't have that much time to find, read and understand. So read it before the exam.

3. There are sample exams for each exam. Make sure you practice those questions until you feel you really nail down each of them because they are very close the real exam. Most of the questions on the exams are based on your understanding. So as long as you understand all the reasoning and logic behind each question on sample exam, you will do well on the real exam.

4. For the group project, the first 2 phases are ok, not that time consuming. But the last phase really took a lot time to finish. So make sure you start early. The final phase is graded purely on the demo. TA normally does't look at your code at all. You need to understand each specification to have the right implementation.

5. Leo and the TA team are very active and responsive. They do have more rules than other courses, but just follow it and you will be fine. Leo is present in each office hour and answer all the questions regarding to lecture, textbook and sample exams. I want to specifically be thankful to Alex. He is the TA answering pretty much all the technical questions on piazza. He usually answers your question within 5 minutes. Alex is very knowledgeable and technical. His answers on piazza really help me to understand a lot concepts. So thanks Alex.

Where to begin... This was my second course in the OMSCS program and would also satisfy my second foundational requirement. I began the course with over 13 years of software development and database experience. My initial expectation was this class would focus on implementing and querying databases. This couldn't be further from the truth, but I did finish the course having learned some new topics. The exams covered most knowledge gained from the book and lectures. The project was interesting and focused primarily on generating SQL queries. For anyone who hasn't taken a database course before, this would be a good introduction. If you have database experience, don't expect much more than your undergraduate database course, given you can get past the vague specifications, some condescending and argumentative TAs, outdated material, tricky exam questions, and unreal expectations at times.

Assignments

• Onboarding Exam (1%): This was a simple exam. The intent was to ensure you read the syllabus, policies, and procedures. While it seemed a little ridiculous, it was quick and simple to complete. Plus, you can keep taking it until you get a 100.
• Team Formation Survey (1%): Given there is a team project, the instructors allowed students to pick their team. Otherwise, you would be assigned to a team. There was a special Piazza post to where you could announce you were forming a team and looking for members, or you could chime in and ask to join someone else's team. This helps to be in a team of students near you, in the same time zone, or maybe worked together in another course.
• Course Policy Review (1%): This involved just looking at each policy page for the course. Very simple. Just look at and read the pages.
• Exam Policy Review (2%): This involved just looking at each policy regarding the exam. Very simple. Just look at and read each page before taking an exam. You have to do this for each exam.
• Teammate Evaluation (10%): I can't stress it enough. FORM A GOOD TEAM!! At the end of each phase of the project, you are required to do a survey where you will rate your performance and the performance of your teammates. Take this seriously. Your grade will reflect upon the feedback of your teammates.
• Exams (12.5% each): There were 4 open book and open notes exams, and each had their aspects of difficulty. My ranking of the exams in order of least to most difficult are: 3, 1, 2, 4. Most of the material comes from the lecture and books, but there is somewhere you must apply your knowledge.
• Team Project (Phase 1 10%, Phase 2 10%, Phase 3 15%): There are three phases to the project. Phase 1 involves high-level design documents. Phase 2 involves lower-level design documents, schema creation, and query creation. Phase 3 involves implementing an application, but the grade for Phase 3 is based entirely on your demo unless they suspect academic dishonesty.

Take-Aways

• Miscellaneous Stuff: While the onboarding exams and surveys seem a little dumb, they are easy points. They don't take long, so just do them.
• Textbook: This was essential to the course. In this class, we used the 7th edition of Fundamentals of Database Systems. The interesting thing is I kept my DB book from my undergraduate course in Fall 2004. It is the same textbook, just the 4th edition.
• Team Project: FORM A GOOD TEAM!! The project consisted of three phases which would mimic the software development process for an application with a database back-end, going from design to implementation. While the project applied the material learned in the coursework, it wasn't very complicated. Read the spec carefully. Have a good team that will start early on the project, meet often, and are true team players. If they aren't, your project and team evaluation grades will suffer. Phases 1 and 2 were primarily focused on documentation and some query generation. You would think Phase 3 would be focused entirely on the SQL you write, but this is far from the case. Phase 2 requires your team to do a demo of your application which utilizes all the SQL you created. While they only look at your code if they suspect dishonesty, the grade is focused on how well your demo shows it meets the specs and in the time allotted. Multiple times throughout the project, our team had disagreements with the spec or did not create entities the TAs felt needed to be created. When several people encountered the same thing, all conversation went quiet with no explanation. As a result, our grade suffered a loss of a few points on Phases 1 & 2 due to a table not being created that we were then told could be excluded in Phase 3 if the functionality worked properly. The TAs could never explain or agree the issue was unclear. Instead, they refused to reply to students on this topic. I can't stress it enough... FORM A GOOD TEAM.
• Exams: The exams are based mostly on material covered in the lectures and in the textbook, and they are not cumulative. They are also open book and open notes, but your notes must be in PDF form and on the screen. Physical notes are not allowed nor is scratch paper. Be prepared for some tricky questions, so read the questions entirely. They state there are not supposed to be any tricky questions, but our exams were plagued with them. Once the exams are returned, be prepared to fight for points back. It never failed, but within 24 hours of getting exam grades, students were fighting for points for poorly worded questions. While I took over 100 pages of notes from the textbook and lectures, at times, I felt they were not sufficient enough to help take the exams.
• Professor and TAs: Leo knows his material and easily relates a real-world experience with the assignments. He is very active in Office Hours and made the course interesting. Will Johnson and Peter Graening filled in a lot of the gaps and were very active in Office Hours as well. Alex Yanovsky, on the other hand, made the course miserable. His comments could be interpreted as demeaning. He was more focused on being right than ensuring the students understood the material. He was unwavering in his viewpoint, and if he knew he was wrong, he would cease replies on the topic. While he replies to Piazza posts within minutes, there was a constant tendency by Alex to be belittling and condescending to the students while trying to prove his intelligence.
• Overall Grade: I feel like I put a lot of time in this course (260 hours), took a lot of notes (110), read a lot of material (400+ pages), and pulled my fair share of the team project. Even with 90+ on the three project phases, good exam scores (80, 89.3, 96, and 72.4), and 100% on the other items, I still managed to only get a 90.21. The high-weight of the exams makes it a challenge (not impossible) to get an A in the course.

TLDR

In short, if you have had a database course and/or have database experience, this class may be a waste of time; however, if you are needing an easy grade or refresher, this class may fit the bill. Be prepared for outdated material, TAs who are more focused on both proving their intelligence and being right, a semi-interesting project with vague specs, exams plagued with tricky questions, and spending time defending your answers to questions. If you have Alex as a TA in the course, may God have mercy on your soul. Read some of the other reviews for the course... they aren't far off from the truth. And, FORM A GOOD TEAM.

This is the first course I've taken in the program.

A lot of the material in the textbook and class is actually related to set theory, so it is helpful to put aside the notion that the purpose of this class is to teach you SQL. The class is more about understanding the theory and design of databases and how to build an application from a database first perspective.

The lectures by Dr. Leo Mark were very well thought out and clearly explained the topics, but they alone are not enough to be able to do well on the exams. Getting the book and reading it are essential to success on the exams.

For the project - there is one group project that has three phases. It is important to get a good group together to be successful. It also helps if at least one person in the group has experience with a WAMP/MAMP/LAMP stack since the suggestion is to do the application in php.

I've seen several other reviews comment about the ever changing project requirements. While those were annoying, that's also pretty typical in the real world, so I'd say it's more to make sure you are designing things in a way that your design can change as requirements do.

This class definitely brings you back to the basics of database design and implementation. It spends a lot of time forcing you to slow down and think about the decisions you make rather than just jumping into implementation like other classes do. From my experience, the skills Professor Mark and his team teach are often underutilized and unappreciated. People who are used to and enjoy rushing to a solution will probably not enjoy the cadence of this course. It necessitates being thoughtful about the decisions you make and paying attention. When it comes to the projects it is definitely a case of go slow to go fast. If you put in the time during the first two phases, the third is really simple.

The courses are well structured. Four exams are easy as long as you watch the lectures and read the corresponding book materials. The project is a bit challenging, but we have a wonderful team. The instructor and the TAs are very kind and knowledgeable. This course is one of the best, in my opinion, offered by the OMSCS. I highly recommend this course. By the way, I didn't have any prior CS background. The previous comments are very subjective and misleading.

I am having a Non-CS background. So, My comment would be from that perspective.

It was my first course in OMSCS. I learned a lot from this course.

50% weightage of Exams: The 4 exams are of Medium Level difficulty. The topics mostly covered in the lectures and against each exam there is a sample exam available. So, one can get the idea which kind of questions are going to be asked.

35% Group Project: It was bit difficult. But you have a good team you will go through it.

15% Mics: Team Evaluation, Exam policy review,

Overall for Non-CS background as a starter it is good course.

TLDR; Pick something else. This course is an exercise in dealing with inadequate specifications, stale content, combative TAs and User Interface design.

I read this in a previous review, and I couldn't agree more:

"The most challenging part of this class was reading and staying up-to-date with syllabus contents and class announcements. All of these seem to be deliberately verbose and poorly organized. And you are warned against asking questions which are answered in these unwieldy, awful docs, because the information has already been provided. This class felt like a middle school test over following directions. I honestly felt disrespected and like I was being treated like a child."

Miserably worded questions on the exams, and emphasis on ANSI-SQL syntax that is never used. Is there a modern RDMBS that implements EXCEPT ALL?

And, of course, Group Project. Which is poorly defined, and has at least 1/3 User Interface design that has nothing to do with the DB. But don't question the specs. The TAs are overly.. well.. rude in the Piazza chats if blatant contradictions are brought up.

One exam had 3 out of 25 questions pulled because of incorrect wording, or content that directly conflicted with the text/lectures. 3 of 25. Seriously. That's a pretty high failure rate by any measure.

So, as an elective in Database Design, this was not on target at all. Perhaps if it were renamed "Pedantic Rules On How To Take This Course" it could better capture the spirit.

Course is okay if you have SQL background.

Exams are alright if you have some SQL background. It was open book so helped avoiding the memorization part. And most of the questions were about understanding the queries but final was a bit painful since it has many restrictions as no notes or no note taking.

Group project was a pain and didn't help learning a lot.

TLDR: unnecessarily complicated, old impractical lecture concepts that you probably won't use at work, confusingly worded exams, ok project depending on team members.

Coming into this course already with background in databases, I try to assess this course objectively, but have difficult time finding good things about it.

Unnecessarily complicated ways to explain: You follow along Leo Mark's recorded lecture on a bunch of topics ranging from SQL, EER, etc and he recently retired. His lecture were good in cases where he tries to use visual examples (ex: use a phonebook to demonstrate binary search) and analogies to explain concepts but in 99% of the case, what's really a simple concept is very unnecessarily overcomplicatedly worded and difficult to understand, and there are tons of other great online lectures on coursera, edX, Udacity, youtube that can explain, for example normalization or join types at a much simpler way. Almost all cases, I went to different online lecture sources to clarify course lectures. Surely this is an academic course (actual masters) compared to online ones that tend to be more practical and hands-on in nature, but being academic doesn't mean it's good if you can't make a person understand easily.

Tests: Tests are also worded weirdly and everything is in a checkbox (so you don't know how many are correct, etc). That's fine but with Proctortrack, that makes things inconvenient, and I didn't really have motivation to study because as I was solving and studying for these concepts, I already knew these concepts are so old, boring, and you're never gonna use this or talk about it (all these calculus and old way of doing things).

Teaching staff: I also need to agree with what most people said about teaching staff.

Project: just like any group project, success of your project depends on if your team has a subject matter expert in PHP and SQL. I think this part is probably the most practical part of the course as you can write on resume you developed SQL databases in MySQL and developed front-end in PHP, etc. But if you already do this at work or something even better using modern relational/non-relational databases + cloud, your interviewer probably won't be impressed by this. I am aware many voiced that these are also outdated methods.

Who should take this: if you don't have a formal study experience with RDBMS, i think it helps enforcing some rules and logic in your head further polished by projects, just that the whole course experience is something I can't say would be a positive one. If you're a data analyst typically just exposed to views, this course helps to understand how databases are created and what DBAs and DB developers go through to design tables that analysts and other uses can access with convenience as poor table designs result in multiple joins and weird logics. but again I really didn't like the whole experience or way things were delivered.

If only there were a rating below "strongly disliked" - "HATED".

This class was a tremendous waste of time. If you have ever used SQL, do not take this class. Hell, if you haven't used SQL, do a weekend-long MOOC, and still avoid this class. The information was not advanced, the projects were not challenging (and a large amount of the work was unrelated to DBs).

The most challenging part of this class was reading and staying up-to-date with syllabus contents and class announcements. All of these seem to be deliberately verbose and poorly organized. And you are warned against asking questions which are answered in these unwieldy, awful docs, because the information has already been provided. This class felt like a middle school test over following directions. I honestly felt disrespected and like I was being treated like a child.

Don't even get me started with the misery around proctortrack and the dreaded "room scans" (which mind you, I have not had to perform in any other class - most of which had closed notes tests and actually difficult content). That alone had me ready to give this class the lowest ratings possible.

In summary - unless you are burnt out and need a cupcake class to graduate, DO NOT WASTE YOUR TIME WITH THIS CLASS. And even in that case, be careful, bc this class is easy but agonizing.

For those who have no clue about Databases, this courses maybe of some help. For those who have modeled databases before or are aware of normalization or know SQL, this is a dated course.
This course spends an inordinate amount of time on relational algebra, tuple calculus etc. Ideally all this should have been quickly covered and completed within a single chapter. Database engine design, SQL compilers, data storage strategies, indexing strategies etc found little mention in the course when these concepts are arguably the most important in modern super scaled applications. This course forces you to design applications, database upwards. That concept is pretty old and modern applications are not build like that.
New age data storage systems such NoSQL databases, Columnar storages, distributed storage, sharding etc found zero mention when they should constitute literally half the course.
All in all this course will add no value to a regular software engineer. Might be of some basic help to non-software people.
About the TAs and general course management:
They tend to talk down on you and treat you like little kids. They write long dreary pages after pages of instructions often repeating stuff over and over. They have this general attribute about "don't ask this please because we mentioned this somewhere in our instructions page" and so on. People are often forced to be apologetic when asking questions because of their crap attitude. I think the TAs need to grow up.

Too many tests and while the project was great for someone interested in learning how to practically work with databases, for someone already working with databases on a regular basis it was a big disappointment. The group project was terrible since I got stuck with a bad team. The only interesting part to me was the coverage of physical storage and the theory behind it.

I wished that I have taken the course in earlier semester when Leo is still teaching the course himself.

Quite good coverage on theoretical aspect of database, but not too up-to-date.

The project, especially part 3, does require the team has some basic web development skills, in additional to database alone.

3 exam, group project with 3 parts (continuous). SQL (any relational database tools you like) + PHP (or some other front end language you like)

I see a lot of negative comments for this course and some of them I agree with, but when i took this course (Fall 2018), the TAs were responsive and the prof Leo was active on the office hours. I personally found Dr Leo passionate about teaching and this course. As mentioned in the other reviews, there are some annoyances about the exams and tests but ignoring those, my overall experience was good.

This course probably doesnt deserve to be a grad level one, but for someone with no dB experience, there were some good take aways including a full stack development. My area of experience has been in drivers and some services backend application in C/C++, so, this course helped me connect/converse with a different set of developers and think orthogonally. But I dont think it has enough depth required for a grad level course.

Pros: Good intro for someone with no dB experience Intro into full stack dev for beginners (the project requires us to develop a front and backend)

Cons: This course desperately needs to be updated with more modern concepts with atleast some noSQL dBs, the working, optimizations etc

I'm not sure how some people only spent a few hours a week. Maybe if you get lucky and have a functional team, you can save some time. I ended up doing majority (90%) of every single project. My teammates constantly complained about how hard things were or they kept dictating the direction of the project without providing help to complete it. The TAs respond really fast, but they always contradict each other. I've gotten points taken off my project for something one TA confirmed I didn't need but another said I needed it.

As far as the exam goes, you will need to do a full room scan which isn't that bad. They don't allow hand written notes and scare you into not taking notes at all (or so it seems), but make sure you bring notes (formulas) into exam 3 especially. The first exam was easy, but the second and third exam are a little challenging. I took this class in the summer semester and had project 2 and exam 2 due the same week. It was really stressful and caused me to have lower grades on both. Exam 3 was just a little harder since I didn't bring notes into the exam.

The TAs for this course must be really smart to have written such an intricate set of rules.

The rules were so intricate that even the TAs themselves could not even understand them, as they falsely gave out a bunch of zeroes.

It wasn't until we had to shove their noses in their mistake that they grudgingly admitted their oversight. I bet they're usually super competent, which would explain how they got to be so condescending.

The intelligence of the TAs was brought into sharper contrast by their complaints about how dumb our current class of students was. They imparted the wisdom that the reason our class did worse than past years is because this group of 500 students is simply much dumber than every other year. Indeed we lowly idiots were lucky to have such mighty and patient educators.

Good luck to next year's class. You'll need it.

I would not recommend this class because the instructor and TA, Will and Peter, are rude and unprofessional. Their office hours consist of them complaining about students and rules and Piazza answers are mostly repetitive "PLEASE READ THE DOCUMENT."

The list of rules is very complicated and difficult to understand, so around 20 students got a 0 on exam 1 for using Google Docs notes. The TAs claimed it was online access and barred by the rules, but eventually had to return students' grades when they realized they did not put it in the rules. Exam 2 and Exam 3 were harder than previous semesters and got a ~65 average, compared to ~80 average on other semesters. One question had 1% correct answers. The TAs are more concerned about being right and their ego than the students' learning.

The final project is a little bit challenging. It requires a lot of teamwork. But I think I learned a lot in the project. The content of the class is highly focused on database theory, which I dont think useful.

I have taken 8 courses in OMSCS and this course was the worst all round. There are 3 exams and one project. Exam 2 carries equal weight as the total of Exam 1 plus Exam 3. There's a rigid policy about everything. Eg. You have to read the exam policy before the start of each exam or face point deductions! If you take hand written notes then for open book exams, you are required to scan your notes because it has to be visible on screen while you take your exams. This is an easy course but I was stressed all through. If you already have experience with relational database systems and need a refresher then I recommend you take another online database course outside OMSCS.

My sincere advice, avoid this course. There are much better courses out there.

Prof Leo Mark wasn't our instructor for Summer 2019. We had a couple of lead TA who managed the course and they were unable to create a good learning environment. It seemed like instructors were alway talking down to the students, simple things like asking a question on pizza would get replies like have you searched for similar questions before posting. The take aways for me from the office hours were a bunch of discussion around logistics surrounding the class and this tedious recital on how students have been cheating. It was such a let down that I stopped attending office hours.

If you don't have any prior database experience (like me), there is stuff to learn here. And the group project presents a real world scenario to apply what you have learnt. I had a great team, so had a ball with the project (I dont want to go into the details of projects grading and stuff cause its a mess). However, if the TA team remains the same, put your head down and do your work and have minimal expectation from the supporting staff - try not to get bogged down their attitude cause it can be very frustrating.

Good luck!!

I don't recommend this course. I also met the first individuals on this programme that give the university a bad name.

Firstly the instructors wrote really dull ambiguous questions that could have at least two different answers. Their justifications for this were ridiculous.

Secondly, on the group project, the little madam in our team (who wrote a rather cheeky review below), did pretty much nothing for our group project apart from being rude (like she is below), she had an attitude problem thinking she's better than everyone else, when in reality the whole team altered their approach to meet her demands, while she waltzed in, set up the framework for what she wanted to do, and then buggered off into her little privileged and self overblown imagery.

This is why I withdraw from the group project, because I could see exactly what she was doing and I tried to steer the team away from her silly games but it was too late. She acted like she worked so hard to set up the Flask script and then drifted off to noddy land. The other two on the team did all the work, she did pretty much FA and admittedly I did sloppy work for phase 1 and 2, because I was in the middle of a move, and also I struggled to remain interested on this topic together with finding little madam difficult to deal with.

The annoying student appeared to me to be a bit unreasonably sure of her abilities, threw her weight around knocking others down with silly comments like 'I suppose the keyboard is mechanical' to someone with a mechanical engineering degree, she refers to this person as a 'junior' below (he's a manager at a tech company). She was a toxic body on this group, low IQ, rather dull, and her remarks below confirm this along with her behaviour throughout the course.

With regards to one of the comments below about 'someone who couldn't code', I am apparently that someone with a snotty madam lab partner. I can code fine, I just did not want to code in the setup that she had proposed and realised she'd basically set up far more work than what was needed for everyone, to then mossy off into her little pompous existence and make even more ridiculous comments about other people. She even had the cheek to complain about why her grades were low for the group contribution! Enough talking about that waste of space and good for nothing!

Read all the reviews on here; the majority are a good reflection of why you should not select to do this database course with this programme. It brings the course down, you get drawn to a level of arguing over stupidly worded questions it shouldn't be an issue in the first place (I'm not sure if the instructors passed English to a reasonable level), there isn't really anything to gain from the course that couldn't be learnt in a much more pleasant manor.

I think the exams were different to previous because there are new instructors whom to be quite frank, were difficult to deal with, they weren't to test database knowledge, they were to make you second guess what it was they are actually asking. There were many complaints on Piazza as there are here.

But for all of your sakes, there are far more interesting and important topics you could pay to learn with Georgia Tech. This course IS NOT worth the money, the TA's ARE NOT worth the time. You would learn for more useful stuff about databases by studying online MOOC's on the side of much more interesting courses on here.

Don't say you haven't been warned on this course! I'd say with the new instructors this module is on a slippy slope! The instructors and their methods on this course are quite frankly shocking. They aren't that intelligent and the material they produced for the exams was shocking.

Apart from that, I was lucky on the group project with two of my team mates who did pretty much all of the work, it was a shame for having someone who thinks she's a god on the team, when in reality she's not really all that, just someone who pushes for her own way and speaks for everyone even when everyone else is saying something else (read the reviews). If you do this course (which I don't recommend), it will be difficult to get a good team. 2/3 members on mine were good, one bad apple wrecks the group.

Do not take this course for now.... This summer only had 13.9% student received A, as compared to previous summers/Falls/Spring (around 30 ~ 45 %) A.

Q: Why such low grade?

• My answer: In short, It is because the recent OMSCS Graduated student took over the class as the instructor (Professor Leo retired.). If you ask the instructor that if the course can be curved due to unusually low grades, he will tell you -> "No, it will not be curved. It is summer course, but it does not mean that it is a lite version of 6400. You should still expect a master-level course." However, if you ask why we don't get grade back on time, he will give you the same answer -> it is an SUMMER course and time is limited and shorthanded. Double-standard at its finest.
• Instructor's answer: Students are bad this summer.

Q: What students complained this summer?

• Ambiguous exam questions
• BS policies
• Arrogant and notorious altitude TAs/Instructor
• Canceled exam grades without notice. Why? because they missed the desk scan. Students argued with Dean and received grade back (with penalty)
• Exam 2 and Project Phase 2 are due on the same time. Exam 2 is a combined exam 2 & 3 from spring or fall semester. It is worth 25% of grade!
• Same points off on project phase 2 and 3 because phase 2 grade/feedback is not released prior to phase 3
• etc....

How I feel at the end of the course?

• They made this course VERY unnecessary COMPLICATED with all the BS. I felt bunch of time was wasted. The course material itself is more or less undergraduate level stuff.

While I enjoyed the learning for much of the course, that was primarily a function of my own efforts and being paired with a wonderful team. The teaching staff did an awful job in pretty much all parts of their job description. I cannot recommend this course to anyone unless the teaching staff is replaced with someone who takes their job seriously and are not here to criticize the students all the time.

This was my 7th course overall and by far the worst course I've taken in this program. It's not a particularly difficult class but the tests are genuinely unfair given the lack of a curve and the instructor is unreasonable and unqualified to be teaching this course.

The class consists of 3 exams (non-cumulative) and three phases of a group project that build on the previous phase. The group project is surprisingly good but your experience will depend on the quality of your group so be sure to find people you are willing to work with for the rest of the semester. The project rubric is somewhat rigid which can be annoying at first but I didn't find that it had a big impact overall. My biggest issue with the project was the slow feedback loop for phases 1 and 2 that hindered our ability to make changes before the final presentation. All things considered the project is the best part of the class.

The exams are a totally different animal. The instructor is obsessed with students cheating and constantly feels the need to remind people about the exam rules even at the end of the quarter. We were allowed to have a pdf of our lecture notes (including screenshots but the rules around this were somewhat unclear) and a physical copy of the textbook during each exam. You essentially need the textbook to do well on the exams so prepare to pay up early on unless you're willing to take your chances.

The biggest issue with the exams are that they don't accurately reflect the content or language in the associated lectures. Each exam had an accompanying practice test that was closely tied to lecture (and frankly easy) that gave a false sense of security going into the actual exam. The real exams use syntax from the textbook rather than lecture and cover obscure topics from the book that were never touched upon in the lectures. Many of the questions were also vaguely worded and used obscure syntax in an attempt to trick students. This is made worse by the fact that they class is not curved (meaning you need >= 90 to get an A) and the last two exams had averages in the 60s and 70s. Exams make up 50% of your grade so getting an A requires that you have a team that can ace the group project and hope that can make up for the low exam grades.

Given the exam and overall grading issues I would recommend that others do NOT take this class until the program does a complete rework of the content and expectations. The instructor is rude, unqualified, and unflinching in defense of a grading scheme that is worse than more rigorous courses in the program. Avoid at all costs.

Quick Summary: The actual material from a practical sense of SQL queries and Relational Diagrams is not difficult. The group project and the presentation that you make to the TA wasn't that difficult either if you have a decent group.

What is difficult are the 4 exams that Prof Mark creates that really tests the limits/edge of your understanding of those concepts and maybe wording of the question prompts. And also how each exam is 12.5% of your grade, but usually consists of only 25 questions. Partial credit is not awarded if say in a multiple selection answer, you click on a wrong answer selection and click on a correct answer selection. Partial credit is awarded if you click on a correct answer selection, but not all the correct selections AND you didn't click on a completely incorrect answer selection. That's just how Canvas quizzes are graded.

So if you are iffy on an answer selection, and you click it and it torpedos all the credit for that question, that's 4 points off or 0.5% off your total class grade. So there's really little margin for error in this course. The open book policy doesn't really help except for maybe the 1st test since most questions are conceptual and require some impromptu problem solving ability.

I ended up with 88% in this class (there are no High B or low Bs, they are all 3.0s); about 4 correct answers away from an A. This was my only B out of 4 classes in OMSCS so far. But only 27-29% of the class in the past few semesters get an A, which is similar to the percentage of the As that get distributed in Graduate Algorithms (generally considered the hardest class to get an A in for OMSCS).

At least I got to learn SQL and a little PHP =)

The bad - 50% of grades come from exam. The exams are tricky, like literally tricky, with fewer multiple choice questions(more fill in the blanks). You need to read the question very carefully and still you may not find the right answer,No matter how hard you prepare. The exam 3 avg was 64 and exam 2 was 73. SO getting an A is very difficult and to get a B you have to do well in exams and you have to be in a good team for group projects. I took it as a summer course and cannot recommend it for summer. FInal project delivery time and exam 2 end dates were same, so dont expect your peers to finish the group project for you. A total mess and TA's are very defensive. Lectures are good but outdated for exams.

Dr. Leo Mark no longer teaches this course as of Summer 2019. The instructor is paranoid that everyone is cheating; perhaps there have been incidences in the past, but it made the environment stressful. Unless you are interested in learning database theory on your own from a dry textbook and are able to spend a lot of time on a team project, I would carefully consider whether to take this course. I spent a LOT of time on the team project and it was a bit like a 5-legged race, but I did learn full stack development in the process. I wish that there was more homework with helpful feedback because I felt unprepared going into exams. (I never thought that I would be wishing for homework!)

On a more positive note, I do believe that they are heavily considering student feedback and might restructure some of the class - we'll see. I know that a lot of students gave solid feedback this summer, both in piazza and the course survey.

So some goods and bads on this course.

Good:

Content - Videos are well recorded and the TAs definitely know their stuff in office hours

Project - I think I learned a decent amount about making a back end system by going through the project.

Bad:

Teaching - I think the TAs were actually pretty good for this course. There are some overly harsh reviews but it does highlight a new issue with the course; The instructor is no longer teaching it. This semester Leo retired, which I think leads to a big downgrade in terms of quality of instruction.

Readings - They're pretty dry Grading - It's a little bit harsh. This is my first class where I've actually gotten a B (out of 5 so far). Average for tests is somewhere around a C and is uncurved

Project - Project is submitted in 3 parts and the content of each relies on the preceding portions. Due to the summer semester, feedback was often pretty late and made the project very challenging to complete on time

Overall, I think this was an alright class but I wouldn't recommend taking it over the summer and I think the quality is lower without the original instructor

I felt compelled to write a review about this one after reading the others. To be clear, there's a lot to improve with this course, and I will elaborate on that later, but you should know:

• The class average for the Summer 2019 term was pretty low and this class is not curved.
• A lot of these reviews are coming from people that just got their exam scores back. They are angry that they did not do as expected. Some of what I'm reading as curve justifications by students on Piazza are frankly ridiculous. Examples include complaining that the sample exams did not exactly match the real exams, complaining that the material did not prepare you for the exams (it prepared me fine. I did not use outside resources.), and complaining about super minor details in logistics as for why a curve is justified. This is pretty immature.

Therefore, it behooves you to keep in mind that these students are bitter that they did not get the grade that they want, and the actual behavior I'm seeing directed toward the course staff from students is unacceptable.

Thoughts About Professor:

There was a new professor this semester. My bet is that this person is running the class the first semester as given, in a way that coincides with how the course has been ran previously (there was no curve in previous terms). I think that this person was caught a bit surprised and was perhaps rather annoyed at some of the petty requests by students. On a lot of occasions he was probably correct (regarding the student body quality - I will get to this later when talking about my group project). In other words, it is not this persons fault that material was inherited and people are directing the anger about their low grades toward this person. Some constructive criticism however: If a student says something petty, it's probably better to just walk away for a moment in order to formulate a proper response. There were occasions where the professor came off as a little bit unprofessional in correspondences - not as bad as these reviews are making it out to be.

Thoughts about TAs:

Peter was active on the Piazza. The TA's in this class are fine.

Thoughts About Logistics:

The summer class was compressed and as a result, some of the due dates were poorly planned. Specifically, the second week of the course there was a major exam and the 3 weeks of the course there was 2 exams and a major project demo. It would have been better to have planned this so that the exams were more spread out, and maybe not the second week of the class. There was a big gap in the middle where there weren't any exams and it would be fitting to spread them out in this way.

Thoughts About Course Textbook:

This course teaches to a poor textbook. The textbook had quite a few inaccuracies that I caught due to having experience in the field already. Most of these inaccuracies are due to being outdated and include things like laughable descriptions of what creating a database is like in the workplace, about half of chapter 16 (though tape drives ARE still used in industry along with tape robots, at least at my workplace - the course text says that tape robots are obsolete), and visual diagrams being incorrect due to being created before ORMs became commonplace in the workplace. Please change this course textbook immediately, its trash.

Thoughts about Lectures:

Very well produced, add some lectures on topics such as: transactions, views, stored procedures, database performance optimizations, distributed databases. Ultimately, there's not enough depth here for even an undergraduate course on the topic.

General Course Material Comments:

There are some bad practices that were advocated or suggested in this course, with barely a mention regarding industry best practices. Some of the worse examples include: Strings as primary keys , passwords stored in plaintext, ignoring use of transactions. You cannot do any of these things without being fired or being put on a shortlist for being laid off at an employer. I have personally interviewed candidates and declined them based on doing some of these things in the interview. Please change this, especially telling people to use INTs or UUID as primary key. Also, no one uses MySQL and PHP in industry anymore. This needs to be changed to Javascript, python, go, postgres, etc. The diagrams also aren't used in industry. Almost everyone uses . crows feet diagrams and this course leaves students unprepared to tackle problems professionally by not teaching it.

Comments on Group Project:

This went poorly for me due to calibre of the student body and this class being a foundational course. One of my lab partners could not program at all, and a second one was very very junior. This resulted in only token contributions. I had to do a remote session with one of them where I showed them how to use the command line. One of these people was frankly rather crazy, and I could not do things like go to work or take a nap without this person thinking I dropped the course (because I was gone for like 4 hours, I was never gone for days at a time). I felt like a slave to this person's insecurities and they left their lab partners poor scores due to being, frankly, rather obsessive and nutty. There's not a realistic way to appeal this because the course staff does not look at git contributions. I recommend for the future making this course non-foundational to get rid of people that cannot program (at all) from the group project. I also recommend it being more focused on SQL and less focused on building a web app. Maybe provide a template web app and make the SQL portion much harder. You could also make this an individual assignment to weed people out. Without giving away too many details, the team participation score did not weed out my teammate that could not program at all.

How I Would Reform This Course:

• Every week have a weekly sql homework to get practice on intermediate and advanced concepts. This should be an individual assignment in which we are given a coding template and we have to use SQL queries to get the desired output. Maybe also have a theoretical practice portion on important material like relational algebra.
• Get rid of the book immediately and replace it with something more modern and better reviewed. Teach class based on material in new book.
• Teach industry standard crows feet diagram instead.
• Make course project be a 1 person project (There wasn't actually a ton of work involved) in order to weed out people that don't know the basics of how to write software or computer science. Maybe also adjust this to have more focus on SQL and less on web apps.
• Teach best practices with primary keys, transactions, passwords and so on.
• Increase course rigor by introducing more advanced materials and practice like views and stored procedures
• Get rid of spinning disk section
• Add section on distributed databases and a section on noSQL databases or key, value store
• Focus more on performance aspects of database decision making

This is the WORST class I have ever taken in my 20-year education career. The instructor Will J and his teaching team should be FIRED for their terrible behavior in this course.

I can not even imagine that Gatech can have a instructor which just graduated from this program two years ago and does not hold a PHD degree be responsible for a graduate level course. I can not even imagine any rank 100 college in US would let this happen without seriously consider the qualification of a instructor who will serve for a graduate level course. I got a master degree from another college in other field, all the instructors there own their PHD degrees and most of them are tenure-track professor and a particular expert in their area.

Due to their unqualified character, they lead this course become a drama, lead tons of student, especially taking it in this summer suffer their particular bad teaching style. They are rude, impolite, untrained, what they did is holding a lot of double standard between them and the students. They are particularly rigorous and strict to student, but they will ignore their own mistake quickly.

They never treat student in this course come to learn things, they just use some particular tricky exam problems to cut off the grades. The sample exam they give to us is significant different than what we have in the formal exam, but the instructor and teaching team will not admit these difference, actually they refuse to admit any difference we student found.

They always can have excuse to say something. We student in summer do not have the feedback in phase 2 before submitting our result for phase 3. They will do this in regular semester. This make many student in summer lose points twice as the same bug, but they don't care, they give the excuse that because summer semester is compact our TA can not figure the feedback out on time. What the fuck!? the TA is paid by Gatech, it is your duty to maintain the same grading system and learning experience to summer student the same as regular semester student. If you can not hold the same plan, that's your fault to not make any accommodation to fit the compact summer and simply let the summer student to be responsible for it all. They don't care about that, actually they don't care anything the student's complain.

They treat like they are the god in this course, actually they are just dictator using their ridiculous policy, ridiculous attitude. I am really painful right now to spend my 500+ dollars in this course, learn nothing but face the shitty teaching team. I would rather use this 500 dollars to support homeless person, not to spend that money to buy this piece of shit.

PS: I don't do bad like those can not get B or above, actually I passed it easily. but it is still no doubt for me that this course is a shitty course no matter you get A or B or C, since you will learn nothing except tons of outdated material and useless knowledge that can only be used to pass the exams.

So let me make a equation to express in all for this course at the end:

Unqualified instructor + Ridiculous tedious policy + Untrained teaching team + Outdated material + Useless exam = OMSCS CS6400 Database Systems Concepts and Design

Fairly speaking, this course content is fine to OMSA students who barely has any prior database experience. I've self-learned a ton from the lectures and textbook. However, the TAs are the critical problem. They are rude, arrogant, obnoxious and hostile to students. With that being said, the instructor and the head TA made the experience terrible. It is pretty dumb that they have radio silence during exam period, even if you ask any questions not relevant to exams. Their rules and polices are disturbing but I can understand. What I cannot understand is their attitudes and behaviors. Apparently they have no idea what manners are. They don't usually answer your questions straightforward, and simply not respond to followup questions whenever they feel like it. Some questions have been there over a month till today and still have no one single reply. Very sincere suggestions to the TAs is they should learn polite phrases from their peers of other courses such as simulation.

Be aware of that students are only given 1 weekend (Fri-Sun) to take each exam. However, starting from fall 2019, after Sunday 8pm EST, TAs will just disappear on piazza and not provide any support if your ProctorTrack crashed during exam regardless of any reasons until next day after exam window ends, because according to the instructor and the head TA, they will need to go to bed after 8pm EST.

P.S. The instructor (Will Johnson) is a OMSCS students who graduated two years ago, neither a professor nor an assistant professor, if that means something to you.

UPDATE: 13.9% of students got A in this semester.

Focused on sql design theories. I wrote less SQL query in home work than my DVA home work.

Exams are hard and videos not related to exam questions or project. No home work but had group project and 4 exams.

Also note, this is a foundational course and need to be 80% above if you take and claim as foundational (I learnt it hard way)

I personally feel this course should be completed redesigned. I would not recommend this course at all.

Pros:

The instructors and TA's respond to messages promptly.

You get to know other students while working on the team project.

Office hours each week by lead TA.

You will learn some basic techniques (whether useful or not, I can't say) and learn to design a full stack web host.

Cons:

Unless you know others in the class and/or have background in full-stack development, you are at the mercy of whatever 3 people join your team.

Tests are indeed tricky, even after reading the text, watching presentations, and taking notes from a variety of sources.

Summary:

I ended up with three interesting people on my team. One of them did sloppy work on phases 1 and 2, which caused more time wasted than progress, and the other did very little until the very last minute in the first two phases of the project (and then it was more about judging the problems in the work than helping to make it better). That same person demanded their choice of the stack we used for phase 3, set up the framework for the frontend and backend, and then put their feet up and let me and the fourth teammate do the work until the the last week, when they realized how much work there was and finally got involved. Of course, the last minute work had problems, but what do you expect? I'm lucky I had one stable, capable, and reliable person on my team, whom I could count on to carry the load. I learned a lot about design, but only because of the lazy, unstable teammate who left the project to otherwise be done at the last minute.

The tests were often on gray material, which wasn't clearly spelled out in the textbook, was never addressed in the videos, and was never discussed anywhere else. I worked way too hard to get low grades on some of the tests. I would have loved to have someone clarify the topics so I could have learned them and maybe gotten through the tricky questions, but it was all pretty much a waste.

One of the opening lines in one of the first lecture videos was that "this will be the best class you have ever taken." I was optimistic, and really hoped that would be true. Not only was it not true, quite honestly, it was undeniably the WORST class I have ever taken. From workload / team task distribution problems, to pedantic requirements, to tests that were only there to cut down your score, I have never taken a class that I am so glad is finished.

AVOID THIS CLASS!!!

The material of this class is fair but outdated, the project is interesting, but the course design is TERRIBLE! The instructor is AWFUL.

Project data was intentionally kept until one week before the project due day, which is the same week as a 25% weighted exam.

Exams are full of tricks and traps that were purposely set up to lower your grade.(focused way too much on the wording of the answer rather than the concept itself)

The instructor (Will Johnson) is simply unqualified and doesn't give a flying fk about anything except you complying the stupid and annoying exam policy, the most he thing said was "If you don't do something, It is on YOU", which is true but not with all these crazy restrictions that shouldn't exist on an online MASTER PROGRAM.

With all that being said, just AVOID THIS CLASS, spend the money somewhere else, you will gain more joy from throwing all the money to Atlantic ocean than taking this course.

I want to say first. Read these reviews, and take them seriously as I did not. This course isn't hard, but it isn't easy either. This course is just... annoying. There are a few reasons for listing this class as "annoying".

Just take a harder more interesting course, like Advanced Operating Systems with professor Kishore. That class was the EXACT opposite to what I'm about to write below. It was an amazing course and I highly recommend it to people who are here to not just fly by and get a degree but actually learn something. Its tough but its absolutely worth the time that you put into it.

Now to the reasons why you should NOT take CS6400. If you do take this class, just expect to put in a lot more work than the reviews say that you have to.

First:

The tone the professor takes with the class was terrible. They're "Strict", no ifs ands or butts. I felt like they were talking to me as if I was a child and not an adult in a graduate level course. They seemed to have a bad experience with people cheating because there was an UNENDING LIST OF RULES AND REGULATIONS for the exams that we were forced to read before each exam. That and they seemed super concerned with people getting illegal copies of the text book. I was never going to do any thing of the sort, but I felt watched and looked down upon because they had to say it so many times. Really set me off with the wrong attitude at the beginning and only perpetuated throughout the semester.

They didn't really seem interested in teaching us quality material, more just that this was a basic course to make money and to shuffle students through.

Second:

Team projects suck. I got a bad team. I'm sure others with a good team. those who got on a good team probably feel better about the course. The project isn't hard but when you have somebody who ghosts for the first part of the project and drops the class halfway through the second, and a person who doesn't know basic git commands or how to program. It's pretty shitty.

This really doesn't need to be a team project. It just made it necessarily harder. It's a simple CRUD webapp. You should be able to do this on your own if you get into this program. It might make the "difficulty" of this course increase, but it would help resolve the shitty team mate problem.

Third:

The exams aren't hard. But they try to trick you with the wording. Don't make every question multiple selection with similar answers, make everything essay based so that you can explain your reasoning. This is just being lazy on the professor and TA's part. They don't want to take the time to go through and grade each exam.

Fourth:

This course seems to be framed around being a Database Administrator. From its description I thought I was going to learn some useful things that I could apply at work. I didn't learn anything that I couldn't have learned from watching like 15 minutes of youtube videos.

Avoid at all costs!

This class fails on nearly all fronts. It has outdated, undergraduate-level material, inconsistent and ambiguous exams, a poorly-thought through group project, and a teaching staff that lacks the ability to serve a large OMS student set. This is the first OMSCS class I've taken that feels unworthy of my time and money. I regret taking this class.

If you're thinking, "Man, no one likes this class but I'm really interested in learning cool new stuff about databases," look elsewhere.

Despite the fact that rapid advances have been made in database approaches in the last 10 years, including the rise of NoSQL, this class sticks strictly to relational concepts. In addition, the concepts themselves are fairly basic: there is no discussion of more complex topics like window functions or stored procedures.

With so many exciting advances in databases and data engineering in recent years, this class feels like a missed opportunity. Stay far away and wait until this outdated failure is retired in favor of a modern data engineering class.

tl:dr If you have taken a DB course or worked with them professionally you probably won't learn anything in this course. Exams are heavily weighted and the questions are ambiguous so you probably won't get an A without lots of effort.

This was my fifth course in OMSCS. Overall I think this course is relatively easy but requires a lot of time to get an A.

The course has 3 exams and a group project with 3 phases. The exams were all over the place and watching the lectures was rarely enough. They were all open book. Most of the questions relied on you parsing very specific differences (in one case the TA's argued that an apostraphe in parent's made it clear what they meant. This was not the case). Averages on the exams were relatively low and I don't think they were helpful or useful.

The course policies are obnoxious. They require you to read course policies before each exam and penalize you if you don't. If you make a mistake you will likely get a zero on the exam (which can be 12 to 25% of your grade).

The project was the best part but even that felt poorly planned. Basically they give you a set of requirements and you build a web application (or something similar) around it with a backend relational database. The project proceeds with a development lifecycle the professor made up that no one uses in the real world (basically focus on the database over the actual application). The first phase is all planning and design with unclear deliverables. The second phase is more planning and writing some SQL queries, The final phase is the implementation which feels rushed.

You can't use an ORM for the project which means you are writing your own SQL right into the code. If your group is good (which mine was) this isn't too hard but it so far removed from industry standards that it's hard to feel like you really learn much unless you've never done web programming. Anything you learn here would probably be better learned from a medium post.

Overall, I think this class isn't sure what it thinks you should learn so it focuses on learning theory that few people use followed by implementing an application in a way that nobody actually would. If you have never taken or worked with databases this class will be useful. If you have this class won't be hard to understand the material but will eat up more of your time than you expect.

Pros:

1. Gives you freedom of choosing your own web frameworks and about 1-month to build a full-stack web application with as a team of 4 members. This will be a good software engineering team experience for those Computer Systems specialization folks out there.

2. I picked up some skills (angular, nodejs) which I wanted to learn from a long time. [probably the only reason why I gave this course a neutral rating]

Cons:

1. If you don't do well in exams, you will get a B. Grading is absolute (<90 is A, <80 is B, so on..). I got 89% and a B. So yeah, keep that in mind.

2. Way too many exams. 4 of them evenly distributed throughout the semester. You will be tested on dry and theoretical topics which you probably will never find useful in your career

3. Grading rubric is ultra complex. Small portions of grade are assigned to frivolous activities such as reviewing the course policy, review exam policy before each exam.

4. The focus is entirely on Relational DBs, nothing about NoSQL.

This is a course that really needs to reworked content wise.

I paid like $1000 to take the course and it mostly felt like I learned nothing remotely useful until the last module. Unfortunately the last module felt super super rushed. Wish they cut out all of unit 2, slimmed down unit 1 and 3, and used the time savings for unit 4. It would've been nice too if they talked more about which modern databases (Redshift, BigQuery, Cassandra, Snowflake etc.) have different advantages and drawbacks and things like cluster indexes etc.

If you actually want to get an A in this course, its quite difficult. The class medians for most exams were high C's/low B's. The TAs are very very banal about the grading, which they feel is a necessity to maintain fairness for such a large class. This means that getting an A as opposed to a B in this course more so than any other comes from your attention to detail to exam questions more so than your mastery of the material. That said, getting a B is quite easy. Because I felt like I wasn't learning useful materials, I basically stopped reading the textbook and skimmed most of the lecture videos and still managed to get an 89.

Also there were logistical issues on almost every exam and class project. Like they didnt release grades or comments for project 1 until you already turned in project 2. So you could in theory have been penalized twice for the same errors.

Other than the grading issues, the class project turned out alright and wasn't too bad. I spent most of my time fiddling with bitnami because the LAMP installation they recommended via the class video didn't work on my computer :(. However once that got up and running, the actual sql queries were trivially easy and we managed to a high A with 0 CSS or Javascript.

Background

Mechanical engineering major undergraduate 2 years out so no formal CS education. Transitioned from Software Test Engineer to more Software Development during this phase of taking this course, full time job. Knowing a bit of Python helped a little on some of the homework. Courses taken so far were:

• IOS Spring2018
• SAD Summer2018
• SAT & SDP Fall2018

Classes taken concurrently with this class: CN & DB

I would say by now I have gotten the hang of the program and how it works, so I knew my abilities and what I needed to do.

Summary

Lectures make things much more complicated than they need to be. All about SQL. They make exams unnecessarily hard and tricky. I got lucky and had a teammate who was able to do a lot (ok basically all) of our project because he had a lot of free time on his hands (what a savior). Good thing about that was we didn't have to stress about any of the project so allowed me more time to do my 2 other classes. Bad thing was I didn't actually get any hands-on experience in doing the project, even though I understood what and how to do it. I was able to scrape by with a final grade of 80.02% getting that B. GOT SO LUCKY. My exam grades were 81%, 68%, 60%, and 47% (yeah close one). 4th exam definitely the hardest. Pissed because I made a bunch of silly mistakes on the 2nd exam which costed me a lot of points... But it's all good I got that B. :)

Pros

• No homework, all project based (however this can also be a con)
• Could learn a lot from group project if you have no DB experience at all

Cons

• 4 exams
• Since there is no homework, your grade is HIGHLY dependent on your grade on the 4 exams. Need like average averaged 85+ to get an A I think
• Make things much harder than they actually are in practical use

Tips

• Find good team to work with
• Read the book since exam was mainly based on the that

I'm a new student in OMSCS and I took 6400 as one of my first courses. The instructor is not very consistent about grading and keeps warn students that points might be deducted for some reasons. Tests are generally more difficult than group projects as long as your teammates are reliable. The reason is that lots of problems in the tests are very ambiguous and that the wording is tricky, though they are not that technically hard. PS, you need to read the textbook to do well in the exams. But if you just want to pass this course with a B, it's probably okay to skip reading the book. The average grade of this course is relatively lower than other OMSCS courses. However, it's very hard for new students to get registered in courses, so I still recommend this course as a first course.

I took this class Spring 2019 in order to strengthen my background in databases. After completing this course, I don't necessarily feel that I have added to my knowledge of SQL. About halfway through, I just stopped watching the lectures since I work with databases lightly in my full time job, and that seemed to be enough.

I found the tests not terribly difficult, but definitely challenging. I would take the sample tests before the exam and for the first two exams, that gave me a good feel for the actual exam. The third and fourth exams were wildly different from the sample exams - the third exam went fine, but the fourth was definitely the hardest of the course. As mentioned in other reviews, there were a lot of ProctorTrack restrictions on this class. I had asked a question due to technical issues with ProctorTrack and neither the TA nor ProctorTrack tech support were very helpful in my time of need, so make sure you read the restrictions carefully.

Group project work was interesting, and you were encouraged to group up with people on your own before getting members randomly assigned to you. The project had 3 deliverables, and the 3rd deliverable grade was dependent on a demo from your team. Some of the queries they ask you to write are challenging, but if there are people on your team who work with databases professionally/daily, your team shouldn't have too much trouble.

A major complaint I had about the course was with the Piazza responses. We were short staffed on TAs this semester, and it seemed like only 1 TA answered any of the questions that were presented. At times, it felt like the TA would answer condescendingly or just link to another question if it was a repeat -- but take this with a grain of salt, since you can't quite get an accurate feel of the way things are being said just over text.

Other than that, I did learn at least a little bit about databases over the semester, but not as much as I would've liked to. I still recommend it if you're looking for an informative elective to take with a relatively simple group project.

This is a difficult course to rate.

Spring 2019. The project saved the course. Redundant first 2 phases of the project. Waste of time. The implementation was awesome. The Exams where tricky and do not test your knowledge of the class. The last exam was a smash in your face hard. And we got inundated by too many policies whom distracted us from learning. The course itself spends too much time in theory. The last 2 test covered important stuff. Overall, you might learn some DB stuff but not recommended since it disappoints. I might not pass because of the exams. I did learn a ton tough.

Uhmm... where to begin on this one...

TL:DR; If you have database experience, professional or academic, don't bother with this class.

I felt that this class had a bit of an identity crisis. Overall, neither the class nor the project were particularly difficult. In fact, most of the class felt like an undergraduate introduction to database design methodologies class. In the very end of the class, the graduate-level stuff basically hit you in the face like a cup of ice water thrown at you. The first three exams seemed extremely easy, then the fourth exam, whoa... a TONs of dense stuff that wasn't covered in the lecture materials [AT ALL] or kind of just came out of left field on us. Basically, the first 3/4 of the class sets the pace for failure in the final 1/4, particularly where the exams go. Agreeing with sentiments of previous reviews, if you have any database experience in your professional life or a good coverage databases in undergrad, do not bother with this class. It is it literally a big waste of time. I was very disappointed that it took literally 13-14 weeks to get to the graduate-level substance of the class just to be skull f****d at the very end. I would have rather gotten right to that graduate-level goodness from the very beginning instead of as an afterthought. So, is this an undergraduate DB or graduate DB class? Take it and decide for yourself - on second thought, don't worry about it. Take a nano-course on databases instead or an undergrad course at a decent University.

Speaking of afterthoughts and identity crises, ohhh lord the project. The instructors herald the coming of age for our OMSA brethren by announcing with such excitement, that our project is OMSA balanced this year by making it a 'data warehouse.' Well, that is just the beginning of the story. There were many elements of the project as set forth by the requirements that were obvious 'afterthoughts.' For example, the thoughts that the project designer might have had, 'all hail my glorious data warehouse, ohh, uhmm... oh no, there are no generalization/specialization in this database; well we have-to-have that in a graduate-level course; let's put one here, and put one there, and even though it doesn't make any sense they'll figure it out.' Give me a break, the project ended up being a barely polished turd in the end.

OH K, I am going to contradict myself somewhat here - my review is predicated on the assumption that this class is a graduate-level class - and that is where I was mainly disappointed. Dr. Mark in his lectures, actually does a GREAT job distilling the most important concepts in database design to an introductory audience. Actually, an AWESOME job, some of his lectures are perfect for people coming into database design for the first time - especially the relational calculus, relational algebra, and normalization/efficiency sections of the lectures. My main problem, is that too much time in the course is spent on the basics and then too little time on more advanced topics like closures, their algorithms, and other advanced topics, expecting you do know the advanced topics at an expert-level after wasting the 14 weeks on the basics which doesn't help you learn the advanced course materials virtually at all.

I mean come on, is this a graduate course or not? If so, structure the class like it why don't you?

This was my first course in the program. The video lectures were just average. The tests for the course were all proctored. All the tests were pretty difficult with questions to confuse you ( I would say, if the course was on arithmetic, the lectures taught you easy addition, while the tests were all divisions). Had fun working with my team on the project though. Lot can be improved on the course videos - the font & color of the material was not good (not readable at times) /did not follow standards.

This was the ONLY class in the program I did not like. I am probably one of the only students who did not do well in this course. I did well enough to get through and finish the program, but the material (to me) was painful to digest. The first part of the class was heavy on theory and very dense (tuple calculus anyone?). I have done a lot of work with database and SQL over the years but I didn't find anything in this class that seemed practical. There was a single group project that had several deliverables through the semester. The book for the class was, well, it was a book. It did help explain some of the concepts, but Professor Leo Mark's video lectures presented the material better.

PROs: I felt the professor (Leo Mark) did a very good job in the lectures and was very active in office hours.

CONS: Heavy on theory, which is good for background information but I didn't feel as though I got anything really practical out of the class.

The course itself seems ok but the amount of redtape and policies for everything from room scans to reviewing exam policies often feels like I'm reading the fine print on a credit card application. It's stifling.

I think they could invest some time trying to be more succinct then just inundating students in the attempts to put the blame back on students for not reading the 2nd page of some poorly written policy.

Only half way through so I'll update when I'm further along.

Good things first - the last project was great and actually the best part of this course. We had a great team that collaborated to the project.

I though disliked: a) the forced surveys on team formation and so on that are actually graded and b) the questions in the tests, which are a bit tricky and focused on outdated subject matter.

I fell short of A (by couple of points) despite scoring full score on my projects. So focus on your tests and respond to surveys on time if you want to secure A.

Lectures

Leo's lectures are pretty straight-forward and he does a good job of breaking them into easy to understand topics. Overall I found his lectures way more helpful for studying than the textbook.

Exams

Four examples total and the exam questions are very similar to the practice exams and are open book. Minus the occasional oddball question I found the exams tough but fair. That being said, I was not a fan of the format of the exams where most of the questions had checkbox type answers.

Exam Topics:

1. Database Fundamental; Entity-Relationship Model (ER); Extended Entity-Relationship (EER) Model
2. Relational Algebra; Relational Calculus; EER Relational Mapping
3. SQL
4. Functional Dependencies; Normalization; File Organization; Indexing

Open book only includes physical notes, pdf/doc/text files that are stored downloaded beforehand, and downloaded lecture videos. NO ACCESSING THE INTERNET OUTSIDE OF THE EXAM

Projects

The semester project is broken into 3 phases:

1. Creating an Information Flow Diagram and EER Diagram; writing Abstract Code and a Task Decomposition for each task (feature) in the project; and determining attributes, datatypes, and constraints for each relation
2. Updating your EER Diagram from Phase 1; mapping the updated EER to Relationships; writing SQL statements to create tables; writing abstract code with relevant SQL queries for each task described in Phase 1. This phase can be pretty time consuming and should definitely be started early if you/your teammates aren't familiar with SQL
3. Start this early, you are expected to fully implement Phase 1 and 2 as an application with a working GUI. You have full control over the tech stack your team uses but no data manipulation can be done in the front or backend, all data must come from calls to your database. It helps to pick a tech stack your team is comfortable with, we chose to go with Angular/Python/PostgreSQL because that's the stack the majority of our team was comfortable with. Judging off comments from the rest of the class it looks like most groups went with PHP/MySQL

Overall

The class was manageable and straightforward. but I wasn't the biggest fan of it. If the course title is 'Database Systems, Concepts, & Designs' I would have expected to learn more about both SQL and NoSQL database systems, especially given the growing popularity of the later.

If you have zero experience with SQL this course could be helpful

Don’t bother with this course, it’s not worth your time. The professor is insistent on proving himself right in the weird corner cases he throws on exams (half of which were NEVER covered in any lecture or the textbook) and is somehow convinced that using checkboxes instead of radio buttons on exams is a good idea (while in reality it just generates a ton of stress for students without measuring any more understanding). If you have any issues with the group project they’ll ignore you, so be super careful when picking your team or the last 5 weeks will be awful.

I think the reviews do a really good job at describing what this class has to offer. I thought it was an ok introductory class to the program, and if you don't have database experience, allows you to work through a project to gain a better understanding of how databases work.

My biggest issue with the class is the textbook. No one has the solutions to the answers to the back of the book. So it feels useless to even go through the information in the required readings. For a school that prides itself on being a top 10 CS degree, you would think the class would have its own version of SQLZoo or something of that nature.

I didn't have a lot of database experience before this class, so I learned a lot and enjoyed the group project. If you read the textbook and watch the lectures, then it is not hard to get an A.

I would suggest avoiding CS6400 unless you are really interested in relational databases. The content is an introductory/standard dive into relational database theory, but this particular course can be somewhat frustrating.

The course is set up as 4 exams and 3 group project phases. You will want to consider how tolerant you are of group projects as you may end up doing way more work overall due to low performing group members and the overhead costs of team coordination. People who rate this class highly probably didn't do their share of the group project or only had to pull their own weight as intended. The 4 exams (each 12.5% of total grade) consist of only ~25 multiple-choice questions, but always contain a few obscure corner cases that might not be covered clearly in lectures or book. Thus, it is hard to score really well on the exams. Compounding this is that grading of the exams is asymmetrical such that a multiple select answer easily results in zero points because each checkbox is not graded as a separate choice; thus, exam grades skew low relative to more common grading schemes. Replies specific to course content are usually quickly answered by one designated TA. However, the professor takes a really long time to respond to inquiries about test questions/grading so Piazza gets filled with complaints/negativity. The grade cutoffs are hard at 70/80/90, but points for a few poorly chosen test questions were given back to those on the cusp of the next letter grade. It seems like this class has been run with the same structure for many semesters. Although it is one of the lowest rated OMSCS classes, I suspect that student feedback for revamping the course focus will not be applied anytime soon.

The 4 exams cover these topics:

1. Database Fundamentals + (Extended) Entity-Relationship Model. Mean: 82%
2. EER Relational Mapping. Relational Query Languages (Algebra and Calculus). Mean: 74%
3. SQL. Mean: 86%
4. Normalization, Efficiency + Indexing. Mean: 70%

The 3 phases of group project:

The group project is an exercise in designing a database and implementing a website. For Fall 2018, the specification was a simple Pinterest clone. No rubrics are given for grading and seem to depend on TAs, but grade averages are very high for the project compared to exams.

1. Analysis and Specification. This phase was a bit ambiguous in parts. Expectations on what was required around some of the task decomposition and database locks were not clear. Likewise, no direction is given on how to write the abstract code so it is hard to coordinate team members and produce a consistent report. I did enjoy making the information flow, EER (and later EER to Relation) diagrams since this type of visual language/diagramming was new to me and explained clearly in the course materials (unlike the aforementioned topics); however, I don’t anticipate it being directly useful to me in the future.
2. Abstract Code, SQL and EER to Relation Mapping. This phase was very rushed. You had to learn the majority of the course material in a few weeks in order to complete this phase (and also had to learn relational algebra/calculus for the exam concurrently with this project phase). I felt this phase was the most stressful since there was so much material to learn in only 3 weeks. I did not know much SQL before the course and did come out with a fairly deep understanding/practical experience writing queries due to phase 2.
3. Implementation. This is the phase where I did not do anything related to this class for 4-5 weeks aside from taking the 3rd exam. I had already learned SQL in order to complete the prior phase and this part was just implementing a website (suggested to use PHP and sample stack). I had not used PHP before, but was able to code the majority of the website to full spec in 2-3 days before the deadline. This phase also made the least sense to me from a content perspective. It is all work completely unrelated to databases aside from the fact that you happened to be using raw SQL queries, which were already written in phase 2. I still can’t believe over a month of this class is dedicated to making a basic website when so many important database topics (NoSQL, etc.) were left completely uncovered.

The final week of the course was left to study the practice exam and discuss material for Exam 4, which covered the topics of Normalization, Efficiency and Indexing. These topics were not covered in the project.

I would guess that a smaller percentage of students finished with >90% A compared to other classes I've taken, though the breakdowns have not been released. Update: Checked on grade distributions and looks like only 27% got an A which is quite low for this program.

Nice course and specifically liked the way Leo Mark explains the topics. You will definitely walk away from this class well prepared. Although after more than 10 years in the industry I would rarely use the practices.

The class covers deeper understanding of the relational algebra, EER, etc. Do not expect concepts of NoSQL, Big Data. Even the indexing is limited to traditional disks. The book has limited use, but definitely recommended if you want to solve/practice similar problems.

There was a group project, you can choose to create your own groups of 3-4 students. There is a group formation duration, if you are still not in a group you will be assigned one. The project will evaluate your work based on the principles Leo explains in the lectures, so pay attention to those. You can choose any stack to implement, the DB has to be a relational one though (MySQL, SQL Server, Oracle, PostgreSQL). We chose to go with PHP, since rarely anyone of us worked on PHP. Was another learning and we kind of fared well.

Exams were the most stressful part, mostly due to ProctorTrack. I didn't have any issues while exam, but have heard from other students that there are hiccups. Exams themselves tested on the learning from the lecture. Good class, could have been better. Leo is great, shame that OMS doesn't have any other class he teaches.

Overview: theoretical introduction to databases. Light workload but getting an A is challenging because of the exams. Practical knowledge will almost entirely come from your project teammates who have work experience.

The most important part of this class happens in the first week: team formation. Make sure you have a group that aligns on a common stack and includes members with both front end and back end experience. The teaching staff don't give many details in that regard until late in the course, so be proactive in communicating with your classmates or you'll be hurting in the last five weeks when you actually build the application. The only thing related to the actual implementation that gets taught in this course is the SQL (at a basic level), so make sure your team collectively has full-stack expertise already.

On the plus side, the lectures are decently organized and mildly entertaining. On the down side, the exams are way harder than what's presented in the lectures and lean heavily theoretical. The exams are pretty standard academia, challenging in ways that aren't going to directly benefit you. The professor says there are no tricky questions, just precise ones. Whether you consider this to be academically rigorous or pedantic is up to you. If you're new to databases and want to become a DBA or really master the subject this might be a good course for you, but anyone interested in just using databases effectively may find the theory to be more trouble than it's worth. There's no advanced practical topics like locking, NoSQL, or anything of that nature.

This was by far the worst class I have taken. I covered more material in my undergrad database course than was covered in this course. It is not a graduate level database course, it is an undergraduate level course and not a good one at that. The course highlights are EERD documents you'll never use in real life, studies in how outdated HDD drives work, and an emphasis on SQL rules not implemented in most real-life RDBMS systems. The first half of the course is entirely focused on theoretical database stuff that is far removed from the reality of databases in reality. Some people may be interested in the theory, but it is unlikely to be helpful in any way unless you develop relational databases. The 3rd quarter finally focuses on some SQL but only the very basics and provides very little practice. If you want to learn SQL, do a 3 hours lesson codecademy and you'll learn more. The last quarter of the class focuses on database file arrangement, HDD workings, and indexes. The last quarter is most definitely the most (possibly only) helpful section of the class.

There is a 3-phase group project that has some potential. The first 2/3 of the assignment are doing pointless diagrams and documents that you will almost entirely throw away when you reach phase 3 (just like you do with the first 1/2 of the class). The final 1/3 of the group project is to write an entire pinterest clone application. There is a ton of work that goes into this section and is the only part of the class where you will actually perform a legit SQL query in any meaningful way. Ultimately you will receive no feedback on your queries or your implemented database in any way whatsoever, and can only hope that you learned something.

The 4 tests are all terrible. The teachers believe the information they are teaching you is a gift from the gods and should be guarded and enshrined. Rather than focusing on students' learning of the material and the usefulness of the class material, they focus on how right the teachers are and how wrong the students are. The teachers will simultaneously claim they do not write "trick" questions while saying some of the questions are "tricky." The truth is, they write questions that are pointlessly devious and mostly pull tiny detail facts that are either not true in reality or don't matter in any way.

I think the class should be completely revamped and suggest no one take this class. If you took a database class at any point in your life, DEFINITELY do not take this class. The class is not hard per se, but the teachers make getting an A in the class an extreme uphill struggle no matter how many hours you choose to put into the class.

This course is almost exclusively focused on database management systems (i.e. database setup, sql, relations). The spine of the course is a set of Group projects that take one on the entire journey from database design to implementation. These projects alternate with exams that test a broader body of knowledge. No one project or exam is all that hard but collectively, you have to stay diligent to do well. Expect to study 20 hours for each exam and do 10 hours of work on each project assignment. That 10 hours can go up quickly if you have a bad team, so invest on forming a good team at the start (they have a process for facilitating this during the course).

In terms of quality: the lectures make an otherwise dry subject interesting. The TAs are proactive and helpful. The professor knows his stuff and has a good sense of how to teach the material and test it fairly.

The 3rd phase of the project requires you to build a full-stack app. So knowledge of some front end (e.g. HTML + javascript), middle (PHP or Python) plus back (SQL) is helpful. The hardest part being, not working on any one of those but in stitching those pieces together WHILE working with a distributed team. Make sure you know Git.

Instructor Turnover

In the Summer of 2018, the original instructor (who had recorded the video lectures) had moved on, and a new instructor was just starting. This led to some minor discrepancies between the videos and the exams/project materials.

The head TA was a bit defensive, which led to some Piazza drama, as well.

Project Teams

The most stressful aspect of the course, though, was the beginning, getting a project team together. The project was roughly a third of the course grade, and the anxiety about getting a high quality team was pretty high.

Slack and email were more effective than the Piazza exchange for finding teammates. I ended up with an excellent team, and we all did good work, pulling our own weight.

What I Learned

I learned a ton about relational databases, SQL, git, GitHub, and the Vue framework.

Biggest Gap

The course is 100% focused on the "back end" of database design and construction. The project, however, had a significant requirement to have a user interface. It was stated that the user interface could be minimal, but our team took it as an opportunity to learn about front end development, as well.

What I'll Have to Look Up Later

All of the different forms of normalization.

What Students Complained About The Most

"Why isn't this a 'modern' database class?" Answer: Because relational databases still run the world, and a solid foundation in RDBMS is an awesome place to start when understanding more 'modern' database concepts.

"Why aren't the project requirements...[fill in complaint here]?" Answer: Because requirements definition is literally the most difficult part of creating a database. If anything, the students should have had an assignment where they write a requirement and another student has to implement, providing feedback on the requirement after the experience.

"The Piazza posts are insane" Answer: Piazza got to upwards of 1000 posts, each with dozens of replies and counter-replies. It was truly unmanageable.

What They Did Well

This instructor and TAs were lightning quick in Piazza responses, and honestly tried to address questions and complaints. They were willing to update items brought up in feedback.

Overall, liked the course. Learned a lot from our group project about Node JS and had an awesome team to work with. If you have a lot of SQL/DB experience, you're likely not to get much from this course in terms of SQL/DB learning. It was a good first class for me, and the group project learnings was completely worth it.

Be careful who you choose for the group project. I ended up doing 100% of the database-related work for my team and could only get a whole-hearted response from them once project deadlines were right on top of us.

The course's scope is actually smaller than my undergraduate databases class, but the group project would have made up for it if it wasn't dumped on me alone.

The course is relatively simple. However the subject matter can be dry. The tests and exams are mostly theory and open book which make it quite simple.

Mostly group-based projects, more documentation and design than implementation, but an interesting course.

This course is interesting and you learn a lot of SQL and databases. I wish they had more information about NoSQL and Timeseries databases but the projects are interesting.

See if you can find a group of friends to do the group project with that makes things a lot more fun and creative. Exams are rote learning unfortunately.

Highly recommend this course. Material is easy. Paired it with intro to info sec. The group project is fun.

Its a good introductory course and one can get good marks in it very easily if they go through the lectures only. You dont need to read much else apart from that to get the course completed, but it is recommended to do so. There is a group project which is highly dependent on who are the partners in your group. I will recommend to choose the tech stack with proper care as not just backend but front end work is also there in this project and your tech stack can either help you or delay you based on your level of expertise in that. TAs are helpful and proactive and so is the prof. You wont find any issue which is not addressed properly in the piazza post.

Great course! I knew nothing about databases coming into this course. This was my second course in the program.

A few key notes:

• It really helps if you get on a good team
• They let you pick teams, though if no teams are picked you will be randomly assigned
• Prior knowledge of RDBMS certainly helps but is not required
• Prior knowledge of PHP helps (this was a part that bit me)
• Knowledge of UML helps for the first part of the course
• Textbook is required (buy it off Amazon for $20, or just rent it)
• Only SQL databases are covered; NoSQL databases are covered in the book but not the course
• The tests can be tricky (even if they're explicitly telling you that they're not trying to trick you). Subtle wording makes all the difference.

If you're going down the Computing Systems path or just have a general interest in databases

This was my course #6 and I have had a great OMSCS experience but struggled in this class with the exams. The exams had vague questions that could be interpreted multiple ways, tricky questions and questions that I believe had multiple answers. There were 3 exams counting for about 50% of the grade. The means for the exams I believe were low. There was talk of a different distribution for an A,B,C as in past years… but I don’t believe we received anything different this year. The exams caused a lot of drama where students would challenge the answers, some were overturned but I felt there was a negative tone on piazza with a lot of bickering, limiting my comfort zone on asking questions. I enjoyed the project and team work, it has 3 phases and was progressive one phase building on the other. I had great teammates. I believe the class would be better if the exams are improved upon or the material on the exams is taught. I enjoyed Leo Mark's lectures on Udacity but was disappointed he wasn't involved in the class.

Solid course for the fundamentals of database. The textbook is great and the course design is also good. I like the project design since you can apply for the knowledge into practical application. But summer semester is short so I didn't have enough time to study PHP. Our team had some communication problem which caused the bad results. Make sure you have a good team that everyone will put their efforts into it instead of waiting for the last moment. I would say your team is crucial for your final results.

Tests had poorly formulated questions, which instructors returned points for over the course. Very satisfied with grade. Contrary to other reviews, front end skills are not required as project was open ended.

Easy course, but there were some issues with the exams because of the wording of some questions was not clear. This caused that after each exam there were some complaints and the professor and TAs had to make a decision on each one. The only aspect to improve in the course are the exams for the reason mentioned above.

I found much of this course to be knowledge that I will not be using again and not very helpful. Some test questions were vague which caused the TAs to regrade everyones tests near the end of the course. This was a summer semester so it was a little more fast paced, I assume it would be a leisurely pace during fall/spring. If you don't know anything about DB I would suggest you read some of the book as the exams are not based solely on what is taught in the lectures. One group project, First 2 phases of the project are design based so sort of tedious, Last phase is implementation and thus more engaging. You will create a simple website interface (teach yourself this as the project is very open ended) to work with your created DB. Overall, I enjoyed creating the DB and web interface at the end but did not enjoy much else in the course.

Be aware of the exams.

The material itself was not too difficult especially if you have years of database experience. That said, the exams were artificially difficult because of gotcha questions and ambiguity. I don't feel like the exams did a particularly good job of testing your knowledge. What they really tested was how good of a test taker you are and how good you were at paying attention to details in a proctored environment. An example of this was a question that asked for the answers that were NOT applicable to the prompt instead of which ones were. If you misread the question after just spending 5 minutes or so writing out functional dependencies on notebook paper then your grade suffered tremendously because the tests only had about 25 questions. This is a course where you can know 95% of the material really well but do poorly on the exams because of the way the questions are written. Additionally, the course would have been more more effective if there was a greater focus put on NoSql databases and overall database performance techniques. I left this class feeling like I had A level knowledge but my grade didn't reflect that. The one good thing about the course was the final group project. The TA's did a good job of setting forth clear requirements that dovetailed with what was taught in the course

This is my second class and it was better organized than my first one (CS6262 Security). The workload depends on how you want to study. If you read the book, which I recommend to succeed in the three exams, you will spend about 8h per week. Mostly because reading and watching the lecture will take you that amount. Then you will have at least 6h per week on the assignment if you already know database and frontend development. This is where it gets bad. Why is there so much work requiring developing a whole website? It is not related to database and sinks hours that could have been invested into the development of SQL.

The TAs were military strict: answers were dry and rough (at least the one that was leading the pack). There were many exams questions that were not well written which was subject to interpretations. More preparation should be done and people with experience on how to write question should be involved in the process.

Overall, it is a-okay course but I saw some people struggling because they did not know database which was not my case. I was able to get a final grade of 'A' but I had to work more than expected. As I mentioned, I have been working with SQL for many years and still, I had to spend many hours per week. Also, nothing about new database technologies. Nothing about cloud, scalability, cluster, NoSQL, etc. The course seems to be written in early 2000.

I had the change to be with 3 other teammates that wanted to work and succeed which was pleasant. This course could have been a nightmare otherwise and I might have had to spend more than 14h/week. If you are with lazy or bad teammates you can easily spend 20h/week.

Pros:

• More organized than the first course I took from GT
• Assignments are clear
• TA Active on Piazza

Cons:

• Old tech
• Too much emphasis on the web (UI)
• 1 or 2 examples maximum per topic. You must rely on the book and on the Internet
• TAs are not friendly at all
• Piazza is used by people to fight for a better grade, I stop going on Piazza after few weeks, it was negative and depressing.
• The instructor is absent from the class
• Youtube TAs weekly presentations are not clear. I was able to see only one, every other time the link was saying "not available" and never could be "live" because of the time zone.

You will learn a lot of the theory behind databases - which I liked. This is not an easy A, it will require some effort both on the project and studying for exams. But it is relatively easy to get a B. You'll need to read a lot of the required text and understand it - the tests basically cover the text and lectures so no real 'gotchas' but the questions can be challenging.

We did our demo part of the project in python/flask. We found it easy to divide parts of the project among group mates; it flowed pretty well. Make sure you get teammates that are either good at SQL, or python or both (if you choose to do it in flask)

I'd avoid this course. If you've used an RDBMS for anything other than simple selects, you won't learn much of anything. The TA's make this class madening as they treat any question to them as wasting their time.

Grading is inconsistent and dependent on the TA. We had incidents like being told to label some field with datatypes "such as integer, string, Boolean, and float" then deducted points for labeling a field as a float instead of a decimal. Regrade requests are handled by the TA that originally gave the grade, so if you draw the short straw and get a bad TA as a grader there is no hope in appealing.

If you really want to take the course you will have 1 giant group project split into three phases with deliverable in each phase. The last phase will be a finished application as well as demo that will be performed in front of a TA and recorded. There are three exams, each was open book/notes but not "open internet." The way that policy was interpreted was ANYTHING you downloaded before the exam started was fair game. However once the exam started you couldn't access anything that wasn't on your local hard drive, (so go crazy with screen shot-ing and downloading articles/lectures before the exam starts). Only exception to this policy was that exam 2 forbid the use of any RDBMS or similar software, as it was the exam on SQL. Exam was proctored via ProctorTrack, and consisted of multiple choice (both select 1 and select N) as well as open numerical answers (No short answer or essay questions).

Succeeding in this course is not hard, though it can be maddening. Stay on top of your teammates and don't wait til the last minute to start work. Be VERY picky and comb over the project requirements with a fine tooth comb. If given UI mockups in the project reqs, match your UI to that mock up. Your goal is to get 85+ on the three phases of the projects, then a 90+ on the exams. Do that and you'll get the A. The key is to get lucky with group mates and what TA is grading your project.

Lastly, run any sample calculations in the lectures on your on-screen calculator you'd use for a test. You may find that you need functions that are not present. Figure out a work-around BEFORE the test starts. (Excel is a great at this....)

I took CA-6400 as my first course in the OMSCS program. I found the course to be rather hard (but not unsurmountable). The hardest part was Exam 2 as there is a lot of questions on extended relations. Also there are a lot of questions. However, I was impressed at how fair the instructors were in responding to ambiguous questions. The instructors gave us an extra 2 points for questions that were unclear (or not covered in class).

Pros:

• Extensive theory on the different types of normal forms. You will get a very strong understanding of 1-3NF and BCNF.
• Professor Leo Mark is hilarious too. His telephone book explanation of searches is friggin awesome!

Cons:

• No prep time for learning PHP.
• No mention of non-relationship databases (No-SQL). Example: MongoDB, or MapR, etc.

Overall a good class, but not trivial. The group project near the end can be taxing. It is easy to make light of PHP. It takes time to understand how it works if you are not familiar with it. Make sure to give Phase 3 of the project enough time. Rely on your group mates. They will save you :)

We bit off a bit more than we could handle at the end trying to implement a containerized app, (when we really only probably needed a PHP site,) but I got a lot of hands on SQL experience.

Fun project if you get a good group. Lots of flexibility in application stack.

Tests are not too difficult and open book.

This is one of those courses which can fall into both easy and hard category. Easy to complete the course with Grade B, but will need some work to get Grade A because of proctored exams. Especially last exam was very tricky and was intended to make you lose marks (and grade). Course structure wise, the project (ebay like project) itself is not so much related to course or at least it was far from what I was expecting from the course. I agree with so many other reviews this course is not at par with other Georgia tech offerings and is definitely not worth risking grade. I think this is the only course where Grade B% is more than Grade A%. Overall, if you want easy B then go for it. But knowledge wise you will not gain much from project. I already forgot most of the theory I learnt for exams so nothing much to gain there too. Although the professor and TA's themselves were great in helping students throughout and they are very knowledgeable too but just the course was not great.

This course focuses heavily on the high-level data structure "schema" of relational databases. I learned a lot about how to take a high-level spec's and decompose them into the set of tables that best serve the application.

However, the course feels incomplete. Efficiency and performance are quickly touched on as an after thought in the closing weeks of the course, and there is no hands-on work with significantly large scale data sets (as such, any performance aspects of the toy data sets are trivial). There is also no substantial coverage of concurrency and locking, or NOSQL systems.

The project was a good illustration of how to integrate a front-end web application with a database management system backed web server application. If you have never worked any web programming, the learning curve is pretty steep. I would recommend working through some online tutorials on database backed web application programming sooner, rather than later, if you do not have experience in this area. I worked many extra hours for a couple weeks because I did not have any experience in that area. We ended up using Flask and MySQL, which is probably a good fit for most OMSA students as we all have to know at least Python for the program.

Please also note this was summer term, so my hours are likely higher than during a fall/winter term due to the compressed schedule.

The test was challenging, however, the overall course was not too difficult.

I learned a lot in this course! Before the class I had very limited experience working with databases, mostly making small modifications to an existing design or modifying existing SQL queries. So I really appreciated the thorough coverage of definitions and concepts. With that said, I also thoroughly enjoyed the group project where we applied the theory learned through the lectures (and measured via exams).

This was my first experience with OMSCS exams, administered via ProctorTrack. The spring and fall terms usually have 4 exams, and in summer sessions two are combined for a total of 3 exams.

TO succeed in this class: form a team with SQL guys and front-end experts.

Course is artificially difficult. Very little, if any, of the course material will feel new to anyone who's worked with a database before at all. And yet the exams are challenging because they test on esoteric and abstruse parts of the material.

I had assumed that I would learn about important ideas related to locking, concurrency, and NoSQL. None of these critical concepts were really even mentioned, although I expect that I will at least use the textbook to self-study some of these ideas in the future.

Group project that's a big part of the course is silly. It would be easier to complete it as a single person than as a group, because it's difficult to align on a stack that everyone knows and it can be a bit difficult to split up the work appropriately.

Course material is a little out-dated as it doesn't address NoSQL databases. There's one project, which is a group project, in this class that consists of 3 phases: requirement gathering, documentation and implementation. There are also 10 non-proctored quizzes, each worth 2% with no limit on the number of retries. 4 proctored, but open book, open notes (no internet access) tests.

This is a pretty solid course on dB design. It focused a great deal on theory. Lectures were very well prepared- although I personally prefer 1-2 longer videos edited together instead of having to click through 6-8 short clips. Lectures alone did not prepare nearly enough for exams. You HAVE to have the textbook in order to fully understand the content. The course project was the best part of the course, but (at least my team) spent way more time on the application development than the dB design. I enjoyed this course and working on the project, but be warned- there is very little hands on database design and practical examples.. and quite a bit entity design and diagramming.

I was having lot of expectation from this course but I felt it is not organized properly plus the concepts were not explained that much in detail. My hope after taking the course was to write more complex queries but I don't feel that I gained anything in that area. Even some more light can be thrown towards database performance and storage. Though I enjoyed the ER concept taught in this class. But to me this class is for entry level, I would not suggest to take this class if you have idea about database and expecting much from it though you can go for this one if you want to complete electives. Best of luck :)

I think this is a very useful course. Project bit can be a bit hard for people new to database but it is well worth the effort.

There's 4 exams and a group project with 3 phases. Basically watch 20 minutes of videos and read a couple chapters every 3 weeks for the exams. And the group project has some videos of how to do each stage. Overall about 5-10 hours of studying for each exam and about 10-20 hours of work for each stage of the project. Main criticism is the professors and TAs love "gotcha" questions and grading for the exams and project. If you aren't good with study and work at your own pace you can fall behind as well.

If you are coming to this course with very little experience in databases, as I did, expect to learn a LOT but be prepared to put in the effort. Compared to my previous OMSCS course (6300), I would say I averaged twice as many hours reading through the (often dense) textbook and studying for exams. The real gem was the project, where we learned everything from designing databases with diagrams and understanding DB concepts (EER, IFD, relations), to implementing them using languages and tools I'd never programmed in before (MySQL, Php, HTML, MAMP). It provided me with not only a working prototype of a database in action, but also with a great experience working with teammates who I plan to keep in contact with. By comparison, the four exams only nominally helped to prepare us for each phase of the project, and seemed much more difficult than initial self-study and sample exams would indicate. I think that pacing in the course could be improved; the beginning felt very rushed to complete everything, whereas by the end it felt like there wasn't enough to keep us busy. It was up to us to plan our learning material consumption, but the deadlines with exams and project phases did not always give ideal time lengths to prepare. Professor Mark and the TAs are knowledgeable and approachable, though if you really want questions answered be prepared to ask during office hours. Overall, it was a challenging course and I liked certain parts more than others, but I definitely learned a lot.

This was a class that started out not tame, but really ramped up towards the end. Phase 3 is a huge amount of work, and the final test 2 weeks later is the hardest of the semester. You'll spend hours upon hours on Phase 3 and that final exam. The whole class is structured around designing and building a database-backed application (like many websites you might have used). It is a lot of fun to work on Phase 3, since it's all about implementing something using MySQL+PHP, Python, etc that you've been designing all semester. But the graders are rather tough about the first two phases having the diagrams and pseudocode being perfect, when in reality a lot of the pseudocode gets changed when actual implementation occurs (at least in my case).

All in all it's a good class, and the workload you have really depends on your group. But it's more than you think, and I don't recommend taking a second class with this. The workload isn't much at first, but watch out at the end of the semester since a ton of work hits you all at once even with the revised schedule in Spring 2018.

This course is too basic for a graduate level course. To be fair, it did cover everything that the syllabus mentions, and I have a few years of application development experience. But still, I expected it to be a much deeper course. We did not even cover the basics of locking and transactions. I was expecting a deeper understanding of these concepts, as well as may be query optimization which are extremely relevant in today's world of distributed computing. Instead, the course spends inordinate amount of time on ER diagrams and ER modeling, which are outdated tools. Nobody uses them in the industry for any real world project. Piazza posts/questions tended to be left unanswered for a long time, or left with student answers with no instructor endorsement.

I had a great team, so the project execution was fun and painless. But I can see that if you mess up in picking the team (wide range of tie zones, wide range of capabilities etc.), then you might struggle a bit with projects. However, the project itself isn't too hard. Even a single person can do it. The struggle would be with coordinating between team mates, if you end up with a bad team.

The reason I say you cannot Front load the work is only because the team project will only move at the team's pace. Rest of the content can be learned quickly.

Very lightweight course. I feel I wasted a course as I did not learn anything new. It is a foundational course though, so that's good. This is basically an easy version of undergrad DBMS course. Your mileage will vary. I'd suggest keeping it for when you need an easy credit.

Overall I like this class, but I wished the professor and the TAs are more organized (they sometime argue with each other on the requirements for the project on office hour). Also I feel like I spent more time on designing and developing the UI instead of working on the database/sql.

Overall for somebody who does not have a formal CS background, I'm happy I took this as my first OMSCS course. Although it is a database course, it broadly covers/requires other CS topics like web development, disk management, AMP setup and admin, PHP or Python scripting. I would only recommend the course for students without much database development experience.

I am not a fan of the book. You should get it for the course as a reference and for the exams but don't plan on keeping it.

The exams are not difficult but are not easy to get an A.

I like the concept of the project because it demonstrates "putting it all together," but the Fall 2017 semester version was not well executed. I think the TAs and instructors are taking feedback appropriately to improve it in future semesters.

This course is awesome, I really love it. The exams are a little tricky, but reasonable. The project is well designed if you do not hate to code for a web.

A great database class! Ignore those whiners.

Course content itself is easy and covers basic concepts. If you've worked with ORMs and know basic SQL, you won't learn much. The EER diagrams, schema design, and normalization content is useful. Read a book and don't take the course if that's what you're looking to learn. If you haven't done web development, you will learn a lot from the final project which is a web application. The database component is a decent component to the project, but there's a lot of unnecessary UI requirements. Many requirements are arbitrary and not relevant to the database (i.e. drop downs, radio buttons, printable pages, unit conversion).

Project was terrible. It wasn't reviewed for accuracy or the actual technical requirements that students were supposed to get from it. It was refined over the semester, and felt like the instructional team was making it up along the way, which led to a lot of questions on Piazza. No rubrics were provided for the three project phase submissions. Grading is inconsistent. I had a great group, which made it bearable. Choose your group wisely and try to find others that can complement your skills for the project. There's a team formation period so use that time wisely to find others who are motivated and engaged.

Exams were fair for the most part. The last exam was pretty tough as some of the questions, especially calculation questions on indexes, efficiency, and performance weren't like those found in the book or sample exam. Still possible to do well if you think through it carefully. Be prepared for 1-2 questions that don't cover the content assigned in the syllabus. Be prepared for 1-2 tricky questions per exam that assess small details that aren't relevant or core to the course material.

Instructors were not responsive. The head TA was pretty defensive in some initial threads which didn't create a welcoming or positive learning environment on Piazza. Many Piazza threads were never answered, including exam questions and project requirements. The instructor asked for feedback in the middle of the course (which many students appreciated including myself) after some students communicated about the negativity on the forums and the somewhat artful deception of the few exam questions I mentioned before. Most of those threads went unanswered even after the instructor said he'd follow up with individual responses.

Hope positive changes actual take place in future offerings. I'd recommend the class for those uninitiated with web and SQL. A lot of people already familiar with databases tend to not like the course.

Spends 75% of the course on basic concepts you should know if you know anything about databases. The other 25% is a shitty overview of database performance. The project is a mess. The requirements document is a garbled word vomit of ideas and requirements which really hurt the head. It is really 75% web development project and 25% database, which is a mistake by whichever idiot thought up the project. Done properly the project should take 200 hours to complete, which is an inappropriate amount of time a project in an ms program should take. Overall this class was terribly executed. Unfortunately the guy executing it makes nearly 300K per year, go figure.

I have database work experience and learn very little from this class. Although textbook has been updated to include new technology such as NoSQL, it is not covered in the lecture. The class project focused too much on web development as opposed to the database. There are a lot of ambivalent requirements which generated tons of questions in Piazza, which led to lengthy discussions that turns into bad feeling and snarky arguments. There is no helpfulness or positive encouragement provided in learning. Lots of negative responses and sarcasm. First, you need to search and read through all piazza posts before asking your question (to avoid annoying the TAs). Second, you didn't get a straight answer most of the time, so might as well do the research yourself. My take on group project: there will always be someone who doesn't do any work. With that in mind, always focused on your own learning and not worry with what other people do or don't. If you're lucky to find good people, it's a bonus! if not, that's okay too. The exams are open book and open note, total 4 exams. They are difficult and tricky. The project is painful and lots of UI work (such as dynamic drop-down parameters). Use PHP to create the project because there will be examples provided. I would avoid this class.

I haven't taken any database course before, and this course is very friendly to those students without a good cs background. Exams are easy and open-book. Projects are a little tricky. Group corporations are very important for projects. I definitely learned a lot about SQL, Html5, CSS, PHP, Javascript and Jquery in this course.

I loved this subject. The instructor was really good. The TAs were pretty understanding when there were grade disputes and most often they favored the students. In all very nice course to learn more about Databases. I wish I could take this again.

This wasn't a hard class, and it wasn't necessarily an easy class. There are two big problems from this semester. First, the project and the exams are completely disparate. There is one set of lecture videos for the exams and another for the projects. It makes budgeting time a little weird, especially since the project is groupwork, so you also have to work around other's schedules.

The other issue is that the project was not well defined. After the first part of the project was completed, it was clear that the requirements were vague and the desired app had a lot of holes. No feedback came for part 1 until a week before part 2 was due. And then 3 was released with a truncated set of requirements.

Ultimately, this course is good if you are looking to learn about databases at a very basic level, and how database development should fit into application development processes.

I felt that a lot of the material was impractical and that the project was poorly planned and designed. I was expected a much deeper dive into the sql concepts but this class instead is aimed at people that don't know what a database is, which in my opinion should not be a graduate level class. If you have never taken a database class or used them then this class is for you, but if you have any real world experience I would not bother.

The course was challenging, but enjoyable. I did have a strong SQL background going into the course, so was familiar with a lot of the presented concepts already. The SQL calculus and algebra concepts were interesting, but gave a lot of people some headaches. The assignments themselves were straightforward but did require a significant amount of web coding knowledge - I had to learn python and Django on the fly. So make sure you choose your team mates very carefully. Tests were straight forward but did require understanding of the lectures. The provided practice exams did give a good idea of what the exams would be like, as well as ideas for what areas to focus on for studying. Make sure to pick up the textbook also, it does help with understanding the presented concepts.

I share no less pain and sympathy with all other comments toward the summer 2017 offering by J Summet and "Head TA Will J. ". I agree with the poor course management experienced by other students. In fact, I am surprised to know my initial post about the comment was deleted here.

I shared no less pain and sympathy with other students who had problem in this course. I also have the same observation about this poorly managed course by the instructor team, especially the "head TA, Will J" and "J Summet". Inconsistent grading without auto grader and compulsory team project. I have collected some of your feedback to Dean Galil. Hopefully we will get a reply from him and I urge you to do so if you had strong negative feeling about this course. No future OMSCS students should suffer our pain again.

The text is clear, formal, and helpful. The project assignments are illustrative, though part 3 is irrelevant and has no place in the course. The tests were well-designed (grammatical errors aside), and despite no previous training in SQL, etc., none of the Database System Concepts & Design-relevant content was challenging. Even for functional dependencies, the course stops short of covering anything but the basics.

Now for the bad: The administration for this course was a clown-car of dropped balls, misinformation, delays, and unprofessionalism, easily leap-frogging "slapstick" into "piteous. " No announcement or instructor response was free from substantive errors. No projected deadline for, say, feedback, was even close to adhered to. The rubric for the final project summed to 90%.

A few weeks into the course, after an exam, someone asked on Piazza (an asynchronous medium) "Would grades be curved? What is the % breakdown for scores for A, B, etc. ? Thanks". The head TA, Terry "Will J" Johnson replied, "Seriously? I'm fighting to get the grades uploaded, and they've been out for about 5 minutes, and you can't wait for me to finish before you start asking questions?" That sort of emotional outburst and unprofessional behavior was common. People quickly stopped using Piazza for most questions, to avoid exposing themselves to that sort of thing.

This course was poorly-planned, poorly run, poorly organized, and had a significant focus on irrelevant material (thank goodness someone on our team knew PHP, that old mainstay of database design). I'm going to take my credits and my grade, reorient my schedule to steer clear of "Will J, Head TA", and traipse the hell away from this dumpster fire. I suggest you do likewise.

My lowest grade in 7 courses before this class was an 89. Let's just say, I sunk lower. This class is not a joke, and I suspect it's not what it was before the change in professor/approach. The projects are expansive and teach a lot about good design. You're working in teams, though, and despite their pleas to the contrary, that means you're practically only going to get hands-on experience with some of this.

The exams, are - to me - a bummer. They account for 50% of the total grade. They are 25 questions each, which means your margin for error is slim. And aggravatingly, each contained one or two trick questions that were intended to catch you on some technicality or wording instead of testing your knowledge. I spent probably 20-25 hours studying for each and did not do well on one of them. I've been using SQL databases in my job for nearly 20 years, so this was a pretty befuddling result.

In all, I think the class is in the lower half of the pack for OMSCS. The TAs were great, the professor is active. And while there were a few slip-ups in logistics (dates, grades, etc), I've seen worse.

The course is introductory. The first two phases of the project were ok. In the 3rd and final phase you are required to demonstrate the database with a UI. However they give you no training in creating a UI. If you don't have people on your team who have done this sort of thing before you are in for trouble. In the demo that you are required to give at the end of the phase there is no proper rubric as to what and how you are required to demonstrate. No complete guidelines. They give you something called a demo guidelines for phase 3. Even if you have it all working according to those guidelines you will have points deducted because some column is not sorted by date by default. I think the project should only test you on what is taught in the class. Not on how well you create a UI that interacts with your database. That is completely outside the scope of what is taught. This is the part that makes it hard. Otherwise the instructor was quick to respond to many things in piazza. The main TA Will regularly took part in office hours. The other TAs are invisible.

This was one of the best classes I have taken in terms of usefulness. Was slammed with a terrible group unfortunately so in the end I had some very late nights where the onus was mainly on me to get the project done. I had people in my group that almost did nothing so I can see how this gets a rating of not time consuming. Don't be fooled though, you may have an extremely time consuming project to do if your group is bad.

This was a challenging class for me even though I've been developing with databases for years. The main reason for this is because some mostly academic topics are covered in depth such as query calculus and algebra. These were completely new topics for me. The rest though was pretty much the same you'd learn in any db class

Don't expect to learn much about current best practices in database architecture and design. This was much closer to what I would have expected from an undergrad class. The videos, though high quality and well produced, seemed incomplete and poorly ordered. Video wise I learned much more from the freely available db classes on youtube (by stanford, peirce college, and houston clear lake). The exam questions were more tricky than than a test of knowledge (thus the difficulty rating). And no one in 2017 is going to need that much in depth knowledge about calculating index size. A unit on some of the new db trends (ie NoSQL), would have been time much better spent. Or maybe an actual case study of redesigning a problematic db application.

The class project is more about application programming than anything to do with db architecture and design. The db architecture and sql required were rudimentary imo. The programming, while not advanced, was extensive. Much larger than the db piece. Heaven help you if you get a bad team-- the group project will be a nightmare. Make sure everyone on your team has some level of programming experience.

BEWARE the phase3 of the project. It's graded more about how you do the demo and programming than ANYTHING having to do with DB design and architecture. Even if your app is bullet proof be sure to conduct the demo in such a was as to go through the instructions ONE BY ONE calling out where your app meets the description. Don't count on the TA to ask you about anything you may have forgotten or been nervous and overlooked.

And yes, as stated by the other reviewers, the class was tight and well run, the instructor (Jay) very attentive, knowledgeable, and responsive in piazza.

I love this course. I must say that I'm lucky to get a really great team. With our effort, I built my first application. There are 3 exams for summer semester. The first one and last one are tricky. The second one is all about SQL and it's straightforward.

Overall good course if you don't have a lot of experience developing an application and want to learn. You create an application for a food bank where you can create users, view/edit profiles, manage inventory, send and accepts requests and manage clients to use the services. The content of exams is easy, but the questions are tricky.

Tricky exams. The TAs/Instructor will never listen to any suggestion from students. Don't expect to learn much from this course.

This was my first course in the OMSCS program. I was lucky to have a great team for the group project, so that eased some of the tension around the massive project- which, required a lot of coding outside of SQL. I enjoyed the lectures, which were done by Dr. Leo Mark. The exams were more challenging than the sample ones that were distributed. Everyone on the teaching staff was very responsive and very helpful when questions arose (for me, our team, and for the class).

This class would be really enjoyable if the project was individual. Believe me, if you are unlucky to get a team where people are lost, you'll end up working yourself in a relatively big project (specially at the 3rd phase, you'll miss weekends for some time). Exams are tricky and sometimes feel like they are trying to evaluate how well you capture and memorize random pieces of data from the textbook rather than actually evaluating what you understood from the lectures. Lectures and videos are really nice and well done. TAs are sometimes very inaccessible when trying to get regrades with strong demonstrable arguments, and they'll even respond with things like "because I say so". If you pick it, just cross fingers to get a good team.

Well organized course presented by effective, patient, knowledgeable and responsive instructor Jay Summet, and Will, Emile, Aoyi, Peter, Tosh, and other TAs were responsive and dedicated.

Do not expect an easy "A" (low percentage A's). Lectures cover material effectively and are easy to watch (take notes). Material covers nearly 700 pages from textbook (read carefully), covers EERD, relationships, relational algebra and calculus, SQL, functional dependencies and normalization, as well as indexing. Four exams divided content logically, but tricky questions yielded low class averages (70, 71, 72, 80). Again, read the textbook, view lectures, and take notes.

Semester long group project spans three phases to design and build functional web site with SQL DB back-end. Teams allowed freedom to choose DB and development stack (php, python, java, javascript, etc). Project required substantial time investment. Choose your team carefully based upon skill and commitment.

Great first course, or to take during Summer.

The course is well organized and run; the professor changed Spring 2017 so the exam policies differed from previous comments (most were closed notes). This is really a database-driven/data model/SQL class, so it should be easy if you have experiences with LAMP or similar technologies, and quite a bit harder if you do not.

Most of the workload is in the project, so the hours per week is not evenly distributed; there are no average weeks. You'll either work harder (when building the project) or not very much.

If you do SQL at work, you do have a mild advantage in this class. However, the 4 tests also cover EER, relational algebra, relational calculus, EER to relational mapping, function dependencies, normalization, file organization, and indexing. Exam averages were 74, 71, 85, 69, but project grades had much higher averages, 87 and 90 for the first two phases. The full-stack project this semester was very time consuming, but the database parts were less than the majority of the work in phase 3. Choose your teammates wisely and finish phase 3 coding early because there is an exam and extra work in the form of sample data (3k lines of SQL inserts in our case) and a demo to prepare at the end. Phase three of the project is primarily graded via the demo where you checkout the code from github, load the sample data into MySQL and walk through the demo via Bluejeans with a TA in 25 minutes or less. Check the schedule for your semester, and if its the same, yes, finish coding early. They are not kidding about the importance of practicing the demo. Recent topics like NoSQL and big data are not covered, yet. As mentioned by other reviewers, Prof. Jay Summet was very engaged on Piazza. He and the TAs were extremely helpful answering questions about the material on Piazza and the regularly scheduled office hours. The class was well organized and well run.

This is a very well organized course, thanks to Jay, Will and other TAs. This is particularly true when it is compared to CES 6242, a complete disaster reviewed separately, this semester. Jay is a great professor, he is knowledgeable, responsive, and respectful, though i have a different opinion regarding the exam questions (I run my own graduate course for four years in Europe). Of course, my old friend Will is great as usual, I will perhaps miss his long but detailed posts on piazza in the future.

Being a graduate course, the topics covered here are fundamental, but never assume an easy "A". This course, arguably, has the lowest percentage of "A" among all the OMSCS courses. The exam questions are purposely tricky. There were four exams in total, the grade mediums are below 80 (out of 100) except one exam. Though my grades are 2~4 sd higher than the medium, but I do not believe that tricky questions are good to motivate studies. Another thing I would approach differently is the course content, instead of emphasizing on EER diagram which is essentially a formalization to represent information, I prefer to dig deeper in more practical issues, e. g., query performance optimization, normalization, or non-SQL database. In addition, I suggest to remove exam #3 for SQL and move the questions to other exams, there are so many moving parts in the course, which makes it hard to follow.

In the group project, we were asked to build a fully functional web application with a database back-end. This is not hard but you have to invest serious amount of time. I am having a hard time to believe people only spent five hours per week can contribute much to the project. My advise is that pick your teammates wisely, preferably someone has previous experience on developing similar applications, and read the book carefully.