This course offers a strong, hands-on foundation in the low-level mechanics of database systems, using C++ to implement core components such as indexing structures, schema management, tuple storage, SQL query processing, partitioning, and synchronization mechanisms. As a software engineer, it's valuable to understand these internals.

However, the course doesn't cover the practical, applied side of using databases — for example, how to set up and deploy a database, configure it for different real-world use cases, or analyze and tune SQL query performance. Only some basic lectures touch on these topics.

This is a heavy coding course, and solid C++ skills are essential. The assignments are not easy — they can take a significant amount of time to figure out and get working correctly.

The practice exams, midterm, and final are all closed-book. I found them manageable but not easy, since the content draws from research papers, lectures, and the textbook alike.

Overall, this is a good course for understanding how databases work at a low level, but it requires substantial coding effort. I was hoping for more exposure to practical, real-world database usage, which this course doesn't really provide.

From a non-CS background, I didn't have any previous knowledge of OS, database systems, or other CS stuff. I checked the previous reviews and expected 15 hrs per week but ended up with 25 hours per week.

The best part about the course is the assignments. There are 5 assignments. For assignments 1, 2, and 5, I took about 8–10 hrs each. For assignments 3 and 4, I took about 15–20 hours each. I also spent an extra 30 hrs learning C++ at the beginning.

The lectures and other parts of the course are of low quality. The lectures are brief and don't cover much information. There is a requirement to read the textbook and papers every week, and that is the most time-consuming part. For the papers, there are research paper slides, and it is good to follow the points in them while reading. However, for the lectures, there are no clear instructions on what I need to focus on for the exam.

The exam is tricky. I would say it is necessary to read the textbook and papers to pass the exam, as some of the questions are based on them. However, if you have a solid CS background, it may be a different story. About 90% of the information covered in the textbook is not tested, but I still have to read it because the remaining 10% is tested. I don't have enough knowledge to figure out which parts I should read and which parts I should skip. Some sections, for example Section 18, are assigned as reading, but they don't seem to be related to any part of the course.

Overall, I learn a lot about OS, C++ and database system, but I don't enjoy the course since it does not provide enough guidance

It's a fine class. You're going to learn a lot more about C++, design patterns, etc. than you will about databases.

No need to read the papers/books. Lectures are enough. Exercise sheets and exams are fine, though there are an excessive amount of questions formatted as "which answer below is INCORRECT" which is annoying.

Exams are essentially the exercise sheets + the practice questions given on Ed, with a few extra. You'll do fine if you just watch lectures and do the projects.

For the projects you are given a skeleton and you just fill in methods. It is tedious more than anything else. You are provided with local unit tests, local Docker, etc. and you can submit to Gradescope many times. In my semester we implemented:

• Lab 1, CSV manipulation: https://buzzdb-docs.readthedocs.io/part1/lab1.html
• Lab 2, Buffer manager: https://buzzdb-docs.readthedocs.io/part1/lab2.html
• Lab 3, B+-tree https://buzzdb-docs.readthedocs.io/part1/lab3.html
• Lab 4, R-tree: https://buzzdb-docs.readthedocs.io/part1/lab4.html
• Lab 5, queries: https://buzzdb-docs.readthedocs.io/part1/lab5.html

Overall you will have a decent idea of how a toy database works. It will get you to understand the general data structures, file structures, etc.

I imagine the majority of the class is doing the labs with AI assistance.

Overall the class was OK. Not very challenging and unfortunately felt more like a class on a hodgepodge of topics. If you are looking for a good challenge w/ high payoff then I would suggestion distributed systems, compilers, GPU hardware/software over this course.

This course covers an interesting and useful topic, and it is mostly effective in teaching the material. The course has two exams, two exercise sheets (which are basically just quizzes), and five programming assignments.

The meat of the course is in the programming assignments. This was where I learned the most about how databases work under the hood, and the reasons for why certain design decisions are made. None of the assignments were too difficult, but I would still start them early, as understanding the requirements and boilerplate code can take a bit of time. By the end of the course, you'll have built a very rudimentary DBMS, which is rewarding.

The lectures and exams I felt were more of a miss. They very strongly emphasize C++ syntax, which seems odd for a topic that should really be language agnostic. I enjoyed reading the textbook and papers, and I wish the lectures focused more on those topics rather than teaching introductory programming concepts.

I do think this course is worth taking if you enjoy programming assignments and are less worried about the quality of exams/lectures. If you want to learn about database internals and go in with the mindset that this is a coding heavy class, you will likely enjoy it.

This course has potential to be up there with the more recognized courses, like GIOS, AOS, HPCA, etc. but falls pretty short. The lectures are not and will not be relevant to exams. They provide a high-level overview of the topics and you're better off skipping them. You can expect to gain more relevant knowledge to the programming assignments through the designated readings, which to give credit, was pretty interesting albeit dense. The exams are gimmicky: I don't like the wording of the questions and I feel like it's meant to trip you up more than it does testing your knowledge on database systems.

The best things about this course are its programming assignments, TAs, and the passion the professor has for this topic. The programming assignments are all in C++, but does a good job of giving you the proper harness to run and test. Great developer experience. The TA is very friendly and nice, fast responses too.

I got a C in this course, so take my opinion and review from a student that didn't expect to give much effort in this course.

I wish I took the other database course instead. CS is not my background and this just felt like a C++ course.

Background: not an SWE but fair amount of coding experience and systems courses such as GIOS, AOS, DC, CN, undergrad OS, computer architecture, DSA. Having taken all of those systems courses was definitely helpful for understanding the assigned readings.

I wouldn't say this course is an easy one, but definitely not harder than GIOS or AOS. My impression is that early reviews of this course were done by students who are much more skilled in C++ or when the curve was more generous, quizzes were easier etc. At the same time, instructors offered 10% extra credit this semester, so I wouldn't be surprised if most students ended up with an A again.

Assuming familiarity with C++, the assignments take about 0.5-0.8x the time of a typical GIOS/AOS assignment. Like most other courses, this course's quiz/exam questions could be worded more clearly or precisely.

For me personally, most of the knowledge I learned was from reading the textbook, papers, and studying for the exams. The lectures are very high-level and prioritize teaching C++ too much at the expense of teaching about databases.

I would get rid of:

1. C++ warm-up assignment -- this assignment is kind of a time suck, and the main learning benefit is for students who don't know have experience with C++. But C/C++ and systems programming is already a course pre-requisite and this assignment doesn't teach anything about database implementation, so why bother? Especially with giving students a whole 3 weeks to complete
2. new R-Tree assignment -- coding up an R-tree is cool, but it's a fairly niche index structure and the marginal learning benefit is too small since we already implement a B+ tree in assignment 3

I would have liked to see a coding project on vectorized execution, columnar storage, or log-structured merge trees.

TAs are nice but kind of slow responding to questions and not really transparent about bugs or issues that come up with the assignment instructions etc.

CS6422 - DI - is like a code blog transformed into a class. The "Implementation" part of the name is really the focus here. Lectures typically have this format: "Currently our code uses raw pointers. However, this is not very safe because of .... Therefore, I now decided to replace them with smart pointers, which solve these issues because of .... Let's examine our new code..." You're not learning much about databases, you're just being walked-through how one is implemented in C++. That would still be interesting if it were a deep dive into all the tricks within the language, but Prof. Alraj does not bother. You won't learn how smart pointers actually work, you'll just be given a high level overview.

To make matters worse, the lectures are dry, slow, and boring to listen to. I ended up skipping all and just reading the slides. This isn't a knock on the professor - he hosts 4 Saturday office hours (for a massive 10% extra credit for attendance) where he gives live lectures that are actually interesting. But in the recorded lectures he's clearly reading off a dry script that almost sounds as though it were AI generated. And frankly, in a master's level program I'm not interested in learning "what is debugging?", "what is multi-threading?", and "what is a hash table?"

The worst part about the course, though, is just how unprofessional it is. Not only the lecture slides, but the code implementations themselves (which you download for review after every lecture) are riddled with errors. I don't mean syntax errors, I mean logical "this code doesn't make any sense" errors. The TAs try to wave them away but its clear the professor put little effort into it. There are so many classes in this prestigious program that just don't belong, and CS6422 should be towards the top of that list.

Finally, a note on the logistics - the 2 exams and 3 quizzes are all MC, predominantly theory based. You can bring 1 cheat sheet, and a significant number of exam questions are copied verbatim from the quizzes and practice tests. If you are privacy concious be warned - you have to use HonorLock on all exams and quizzes! Recommend using a LiveUSB. 5 C++ HWs, all in a single file with a handful of hidden test cases, graded on GradeScope. If you go into the course without being comfortable in C++ you will struggle (ex - you will have to implement multi-threading before the lecture "what is multi-threading?)

Overall, DSI was a solid systems course, but it was more rigorous than I expected based on the reviews here. I'll break down the course content by weighing in the final grade:

Lectures/Exams (2 exams, 20% each, 40% total) Lectures are quite dense overall, and the difficulty of each lecture varies wildly. Some lectures review familiar programming idioms (e.g. encapsulation, templating, ...) while other lectures throw slides full of C++ code of new data structures (buffer manager, B+ tree, hash aggregation operator, ...). Depending on which lecture video you're watching, it can sometimes take an extremely long time to comprehend the contents. Exams are quite gimmicky. They are 2 hours, HonorLock, multiple-choice, with about 80% noncomputational / 20% computational. Of the noncomputational questions, they loved to spam "which of the following is NOT true" in the question prompt. Often, the concept was nowhere present in the lectures, so you have to improvise based on what you know and how the question is worded. I thought that these exams mostly tested "your ability to take a multiple-choice test" more than "how much you know about database management systems". Reading the textbook is not required to do well on exams.

Exercise Sheets (3 sheets, 5% each, 15% total) Mini-exams, HonorLock-proctored just like the actual exams. Same question style as the exams (I'm not really sure why these are proctored tbh). One benefit is that sometimes, a question on an Exercise Sheet reappears on an Exam, so that's free points.

Assignments (5 assignments, 9% each, 45% total) These are the best part of the course, though they can be quite lengthy depending on your experience in C++ (I took about 30 hours/assignment on average). Often times they will use idioms and structures that haven't been introduced in the modules (e.g. threading was used in Assignment 1, which was due before the Threading module was scheduled), so it would be wise to review online docs/LLMs to see how to use everything. These are always structured as a single C++ file with a partial test harness in main(). The 5 assigments can be previewed here: https://buzzdb-docs.readthedocs.io/part1/index.html

Lectures were useful maybe 50% of the time. Spent way too much time on c++ and not enough time digging into more internals of databases. I might just be too smooth brained, but I thought the exams were kinda challenging. Wording was strange at times, and I felt they took "practical application of course material, multiple choice, and not much written math" to its limit in difficulty. Some exam questions were on research papers that were provided throughout the semester. I found the topics interesting, but the reading load on them wasn't very balanced. TAs were slow to respond. Office hours were exactly once, 1 hr/week, which was bad, but always with the professor.

The professor himself was one of the best parts of the class. Even though the lecture content was often not what I wanted to be watching, he's extremely happy to be talking about this material. During office hours, he was genuinely interested in hearing from students, helping where he could, and giving high-level overviews of the research papers.

• This course felt like a beta course. It is not a graduate level course (I doubt if this can even be at undergrad level)! The content could have included other topics like Logging, Recovery, Transaction Management, Distributed and Cloud databases, Examples for the features described from modern databases but apparently another course is being prepared for these. If you are looking for a solid understanding of relational databases, just read the recommended book "Database System Concepts, 7th edition (https://www.db-book.com/) and may be go through Andy Pavlo’s youtube videos instead of taking this course.

• As others said, too much time is given for C++ concepts in the lectures, thus depriving of chances to cover other database concepts. C++ must be made a pre-requisite instead. There is a programming assignment just to check C++ concepts, that could have been used for solidifying other database concepts instead.

• TAs were mostly low key on Ed during the summer semester. They took many days to respond to student enquiries. I took a couple of courses before this, and TAs in this course are the least participating ones. Ed forum did not see much activity as the TAs and Professor didn’t respond to student queries within a few days in general (I would expect TAs to field most of the questions within a day or two). There was a time when all of them went completely silent for 4-5 days!

• Lecture slides contained many mistakes from the first run of the course and were not corrected in this run too. It seems like not enough attention or effort is spent to improve the online version of this course. If you are coming to this course expecting GIOS type of rigor and discipline, you’ll be disappointed!

• Exams and exercise sheets were not that challenging. Programming assignments don’t have much guidance via comments. However if you spend like 4-5 hrs per week, you can end up getting an A easily (assuming you have C++ knowledge).

• This course’s curve is the most lenient (if you scored >= 80% you get an A grade, otherwise a B) of all the courses. 90% of the students got A! If I knew this beforehand, I’d have studied even less for the exams and exercises and I would have spent more time in reading the book.

Medium-effort, high ROI course. 4 Assignments 3 quizzes 2 exams

Great class if you are interested in understanding how databases are built from scratch. The assignments focus on implementing a beta version of BuzzDB in C++ and iteratively improving it over the course of the assignments. One of the nicer things is that there are no hidden test-cases. Passing the test-cases locally almost always guarantees a 100% on gradescope. B+ tree (assignment 3) was the most challenging one.

Quizzes: These are proctored quizzes (via honorlock) that mainly focus on the lectures. Combined make up around 25% of the grade. They aren't too bad , but there are 3-5 questions that can seem from material not included in the lectures but need general database knowledge to answer

Exams: Same as the quizzes but with the material from the papers, especially the final was mostly from material in the papers. But the professor mentions the important sections from the papers relevant to the exam. My advice would be to focus on those.

Curve 85% was an A , it looks like the course is getting tougher with time. % of As has decreased compared to previous semesters.

One of my criticisms is the weightage of assignments relative to quizzes, quizzes seem like beta exams, and sometimes I felt that they weren't really needed . Instead they could add up-to 2 extra assignments dealing with in-depth concepts from databases. This is where the course missed the bar slightly.

Overall , a great course, put in the effort and you will be fine. The professor and TAs genuinely care and want the students to succeed. My grade A - (89%)