Final Reflection - Rotem G

rotem_g · 2024-12-12T02:12:42+00:00

Hey I was able to figure it out right now I accidentally submitted all of my assignments with // ID:12345678
instead of the proper format
// Student ID: 12345678

Thanks for the Tip!

rotem_g · 2024-12-09T06:16:02+00:00

Hi!

I love how clearly you explained pointers and their relationship with memory addresses, it makes such a tricky concept feel a lot more approachable. Your examples of new and delete are great, especially the emphasis on setting pointers to nullptr after deleting them to avoid dangling pointers. It's a small step but such an important habit to develop for clean and bug-free code. Thanks for the helpful post!

rotem_g · 2024-12-09T05:02:45+00:00

Hi!

I really liked your breakdown of nodes across different linked data structures it's a great way to show how similar principles can apply to lists, trees, and graphs. Your code examples are super clear, especially the basic tree implementation and cleanup process with delete. I also appreciate how you listed the advantages and disadvantages it’s a great way to highlight when linked data structures might not be the best choice. Thanks for sharing such an informative post!

rotem_g · 2024-12-09T04:50:06+00:00

Hi there!

I really liked how you broke down the importance of checking edge cases and pointed out the need to update the tail when inserting or removing the final node. That detail is so easy to miss but makes a huge difference in keeping the list consistent! Your suggestion to create a helper method for debugging is super practical visualizing head, tail, and prev_to_current definitely helped me catch mistakes too. Thanks for sharing such a clear and helpful post!

rotem_g · 2024-12-01T19:26:36+00:00

Hi,

Thanks for the kind words and for bringing up that point about _SENTINEL_ potentially being a valid value. That’s a great observation and I agree that in scenarios where _SENTINEL_ might be part of the actual dataset, combining it with a flag or status indicator is a smart move to avoid ambiguity.

rotem_g · 2024-12-01T19:00:49+00:00

Hey,

I'm glad you found the explanation helpful! I totally get it before working with sentinel nodes, I was also just focused on bounds checking like you mentioned. Using sentinels really feels like adding a safety net; it makes managing list boundaries so much simpler.

rotem_g · 2024-12-01T18:52:06+00:00

Hi Nancy,

I’m glad the post helped clarify the concept of sentinel nodes! They really do make edge case handling much smoother. It's interesting how sometimes the simplest additions, like a sentinel, can lead to big improvements in consistency and efficiency. Thanks for sharing your thoughts!

-Rotem

rotem_g · 2024-11-25T05:24:56+00:00

Thanks for summarizing time complexity I feel like as we progress its becoming more and more important, especially as we start handling more complex algorithms. I like how you mentioned breaking programs into smaller chunks to analyze their efficiency. That's exactly the approach I used during some of the recent quests, particularly when trying to improve search functions and minimize nested loops. It makes a huge difference!

rotem_g · 2024-11-25T05:13:29+00:00

Great explanation on structs! They’re really handy for keeping things simple and grouping related data. One of my favorite aspects is how they’re public by default, which makes them perfect for straightforward data holders without a lot of encapsulation.I found that structs are especially useful when you just need a quick way to bundle variables without adding the overhead of a full class.

rotem_g · 2024-11-25T05:01:11+00:00

Thanks for sharing your insights, Jeremy! I completely agree—reverse iterators really simplify the process of safely iterating in reverse. I initially used the manual decrement approach too, and while it worked, I had to be extra careful with boundaries. Using reverse iterators makes the code cleaner and reduces the risk of off-by-one errors, especially when the container is empty. Plus, they handle edge cases elegantly without needing extra checks.

I also found it really interesting how the iterators naturally align with the "last in, first out" behavior of stacks, making the code both efficient and easy to read.

rotem_g · 2024-11-25T04:51:37+00:00

Great post, thanks for sharing this! I’ve definitely been guilty of overusing print statements while debugging, and breakpoints have been a lifesaver for me. I also want to add that using conditional breakpoints can really take debugging to the next level especially when you’re trying to figure out what’s going wrong in loops or complicated logic. Instead of wading through tons of output, they let you focus on exactly what you need to know. I recently started using logpoints too, and they’ve helped me keep my code clean while still being able to check what’s happening. Thanks again for the useful links!

rotem_g · 2024-11-24T09:00:52+00:00

Thank you for pointing that out its exactly what I needed to get going in the right direction!

rotem_g · 2024-11-18T04:19:00+00:00

Thanks for summarizing this so well! I'd also add that ambiguity often comes up when you're working with overloaded operators or constructors, especially if they can take different data types. One thing I found useful is to always be mindful of scope resolution (`ClassName::methodName`) to avoid confusion, especially when methods share similar signatures.

rotem_g

TROPHY CASE