Six Hours of Lectures, Difficult Concepts, and an Early Night

Tuesday was another long day of Compiler Design. I managed to complete all three lectures of Syntax-Directed Translation (SDT), but each lecture was approximately two hours long. By the time I finished, I hadn't even found the time to prepare notes.

And there was another factor that made the day more difficult: I was fasting for Hanuman Ji.

It wasn't the kind of day where I could finish my planned tasks, revise everything, and move on to another chapter. I completed the lectures, struggled with some concepts, felt unwell after returning home, and eventually went to sleep early.

Here's how Day 44 went.

Six Hours of Compiler Design

My target for Tuesday was to start and complete the Syntax-Directed Translation chapter in Compiler Design.

I managed to complete all three lectures, which meant spending approximately six hours watching recorded classes.

Six hours might not sound too bad when written as a number. But watching technical lectures is different from simply sitting through six hours of entertainment. You have to follow the professor's explanations, understand the examples, keep track of the concepts, and sometimes go back when something doesn't make sense.

With my October 31 syllabus deadline getting closer, I wanted to finish the chapter rather than spread it over several days.

I completed all three lectures, but I couldn't prepare their notes. There simply wasn't enough time.

This is becoming a difficult part of my GATE CSE 2027 preparation. Completing lectures takes up a significant portion of the day, leaving less time for note-making, revision, and question practice.

For now, the SDT notes remain pending.

The Third Lecture Got Difficult

The third lecture, which covered the evaluation of SDT, was somewhat difficult for me.

I think part of the problem was the way the topic was introduced. The professor started explaining SDT evaluation using an ambiguous context-free grammar (CFG) rather than beginning with an unambiguous grammar.

Since I'm still trying to get comfortable with the concepts, this made the explanation harder to follow.

The main difficulty was constructing the parse tree. I was struggling to understand how the tree should be constructed, and because of that, I also lost track of the order in which the semantic actions were executed.

It felt like I was trying to understand two things simultaneously, and when the first one became confusing, the second one became confusing as well.

For SDT evaluation, the parse tree matters because the semantic actions are executed according to their placement in the grammar and the traversal or evaluation order involved. If I'm already struggling to construct the tree, following those actions becomes much harder.

I don't think this necessarily means the entire topic is beyond me. It may be that I need to understand the basics more clearly before working through complicated examples.

However, I haven't revised the chapter or tested my understanding through questions yet, so I can't claim that the problem is solved.

Notes? There Was No Time!

One thing I couldn't manage on Tuesday was preparing notes for the three SDT lectures.

Each lecture was approximately two hours long. After spending around six hours completing them, I didn't have enough time to make notes as well.

And no, I couldn't magically squeeze another study session into the day. There are only so many hours available, unfortunately.

The notes are still pending, and I'll have to account for them in my remaining schedule.

This also highlights a practical problem with my current preparation strategy. Completing a lecture is one task, but preparing notes and revising the material are additional tasks. If I don't account for all of them, my schedule can look more manageable on paper than it actually is.

For now, I have completed the lectures, but I still need to consolidate what I learned.

Fasting for Hanuman Ji

Tuesday was also my fast for Hanuman Ji.

After coming home, I was feeling very dizzy and had a headache. I ate some fruits and went to sleep early.

I didn't continue studying after that.

With the amount of time already spent on lectures, the fasting, and how I was feeling physically, continuing to push myself didn't make sense.

I had wanted to make progress on the chapter, and technically, I did complete all three lectures. But the day ended without notes or additional study.

Sometimes, the schedule doesn't leave much room for anything beyond the main task. And when I'm not feeling well, even that schedule becomes harder to manage.

The October 31 Deadline Is Getting Closer

I'm now in the final stretch of my October syllabus target.

Compiler Design has been particularly demanding because I'm encountering these concepts for the first time and trying to understand them while keeping up with the lecture schedule.

Tuesday's six hours of lectures are a good example of how much time a single chapter can consume.

I still need to account for the notes I haven't prepared, and I need to make sure that completing the lectures doesn't become the only measure of my progress.

Watching a lecture gives me exposure to a concept. Revisiting it helps me consolidate it, and solving GATE PYQs will help me check whether I can actually apply it.

I haven't reached that final stage for SDT yet.

For now, the chapter's lectures are complete, but the work of revisiting and practising the concepts remains.

Day 44: Lectures Completed, Notes Pending

Tuesday was productive in one specific sense: I completed all three SDT lectures.

But it wasn't a day when I could finish everything I wanted. The third lecture was difficult, the notes remain pending, and I had to end the day early because I was feeling dizzy and had a headache after fasting.

I ate some fruits and went to sleep.

There isn't a dramatic lesson or a big achievement to celebrate here. I made progress, encountered difficulties, and had to stop when I wasn't feeling well.

Day 44 complete. Three SDT lectures finished, notes pending, and the October 31 deadline approaching.

The next step is to account for the unfinished notes and continue working through the remaining Compiler Design syllabus without ignoring revision and question practice.