CS371p Spring 2021: Final Entry

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

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?

I think the course did a good job conveying them. It was particularly helpful that on top of learning them in the lectures, the projects assigned also covered the takeaways so that we got hands-on practice/experience with them.

• Were there any other particular takaways for you?

One of the things that stood out to me was the importance of knowing how things are handled under the hood. Not only did this allow for more efficient code, but also for greater understanding when certain bugs or weird behavior happened.

• How did you feel about cold calling?

I was initially not a fan of it but got used to it by the end of the course. Covering the material with a student allowed for refreshers or more explanations on things that may have been confusing.

• What required tool did you not know and now find very useful?

I had known of docker, but had never used it before. It was very handy being able to make an image (or use one) to easily set up an environment. I probably will be using it for future classes for group projects or so that I do not have to reinstall everything by hand when switching computers.

• You should have read five papers that describe SOLID design : Single responsibility, Open-closed principle, Liskov substitution, Interface segregation, Dependency inversion. What insights have they given you?

They were all topics I had heard about (mostly in 314), but I was never really focused on following them. Reading the papers and the examples they described in them really drove home the importance of them. The projects assigned in class gave a good situation to apply them in and see the benefits first hand.

• You should have read two papers that advised minimizing getters and setters. What insights have they given you?

How bad they are… Most of the projects I had done up until now were small scale enough that I could get away with sloppy code and accessing private members of classes directly (or through methods). The papers showed how bad of an idea this was and how messy it could make code down the line that has to rely/use them.

• Give me your suggestions for improving the course.

More time for exercises. I feel like there were enough exercises to offset the ones I performed badly on, but the amount of work/code needed for a particular exercise seemed to vary greatly.