Key Takeaways:
- test first, test during, test after; test, test, test
- when designing algorithms, demand the weakest iterators (e.g., bidirectional vs. random access)
- when designing containers, provide the strongest iterators (e.g., random access vs. bidirectional)
- build adapters on top of containers and iterators
- do not use new and delete; use allocators instead
- always look for reuse and symmetry in your code
- collaboration is essential to the quality of your code and to your well-being in producing it
- refactor, refactor, refactor
- make your code beautiful
How well do you think the course conveyed those takeaways? The course went into great detail for each of the takeaways through the lectures and papers, and we got to put them to practice through the projects.
Were there any other particular takeaways for you? I think it was nice that one of the papers went over the role of women in technology. We didn’t really talk about it aside from doing it for that one assignment but I hope it remains as a takeaway for other people.
How did you feel about cold calling? It would’ve been better if, when a person got cold-called on, they didn’t have to answer so many questions in a row. Since there was so much time spent on one person, it was easy to zone out while that person was answering questions.
How did you feel about specifications grading? At first, I really didn’t like the sound of it because it seemed like too much to keep track of, but it turned out to be fine. I actually think it made it easier to get an A in the long run, since you don’t need to get a 3/3 on everything.
How did you feel about help sessions and office hours? I went a few times and I thought it was incredibly helpful each time. I also appreciated the fact that we got another virtual token from going to them.
How did you feel about the support from the TAs? The TAs were great! They were especially helpful in the breakout rooms during HackerRank exercises.
You should have read five papers that describe SOLID design: Single Responsibility, Open-Closed Principle, Liskov Substitution, Interface Segregation, and Dependency Inversion. What insights have they given you? Each paper had good advice about modularizing code and reducing dependencies between modules as much as possible. As developers, we should remember these insights to write clean and maintainable code.
You should have read two papers that advised minimizing getters and setters. What insights have they given you? They were definitely shocking to read since using getters and setters was instilled in me since my beginning CS classes. It was also a little difficult getting used to not using them in the Darwin project, but after I figured it out, I could see how it is better for abstraction.
What required tool did you not know and now find very useful? I didn’t know about the different types of casts (static cast, dynamic cast, const cast, and reinterpret cast) before but now I see how they are useful for interpreting objects in different ways and exploiting their object-oriented properties.
In the end, how much did you learn relative to other UT CS classes? I think I learned about the same amount.
Give me your suggestions for improving the course, but apologies in advance; specifications grading will remain. Nothing much other than shortening the amount of time spent on each person who gets cold-called on.
