CS373 Fall 2022: Fernando Mercado: Final Entry

 

Intended long-term takeaways from this class:

• test first, test during, test after; test, test, test
• when designing algorithms, demand the weakest capabilities (e.g., iterable vs. indexable)
• when designing containers, provide the strongest capabilities (e.g., indexable vs. iterable)
• build decorators on top of containers, iterators, and functions
• utilize the benefits of being lazy (e.g., yield)
• 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?

While there was a pretty significant disconnect between lecture materials and the content of the project, the principles we learned in class were absolutely applicable not only to the project but any coding I will be doing in the future. The best programmer is a lazy one and this class really helped hone my lazy skills.

Were there any other particular takeaways for you?

I was pretty much completely in the dark concerning web dev coming into this class, so that was a huge takeaway. This was also the first time I was really required to test rigorously, and it was great practice because that's how it is in the real world and I really appreciate the practice this class gave me for my future employed adventures.

How did you feel about cold calling?

Cold-calling was not really an issue. Prof. Downing just calls your name, you answer a quick question like what's an interesting fact about yourself and he walks through a section of class, asking you a few questions before moving onto someone else. If you're prone to nervousness regarding this type of thing, don't worry, he does a good job of not putting you on the spot, essentially holding your hand through all the questions.

How did you feel about specifications grading?

I personally had a very hard course load this semester, and I had to miss a few more classes than I would have liked. Due to this, besides doing very good in all other categories, I will be receiving a much lower grade than I'd like. If you are taking a lot of other classes and think you might miss a few of Downing's lectures or are prone to sleeping in and missing class, DO NOT TAKE THIS. It is very easy to slip and land yourself in a very bad hole. After missing 10 quizzes (10 sounds like a lot but it's 10 of 42 classes), you lose an entire grade point for every new class you miss. Even if you attend class, make sure to really study the notes from the day before, because sometimes they can be quite tricky and with only 4 minutes to answer 3 questions, it's entirely possible you don't perform well despite attending class.

Take a look at the grading section of the syllabus here. I feel as though there has to be a way to rebalance the weighting for daily quizzes while maintaining a focus on attendance. They're simply too heavily weighted.

How did you feel about help sessions and office hours?

I personally did not have to make much use of these, as the weekly meetings with our assigned TA were more than enough for my group. There are a lot of opportunities available for people who want to do these, though, with 4 TAs and a lot of weekly sessions.

How did you feel about support from the TAs?

I really enjoyed having an assigned TA for our group, and the weekly meetings with them were invaluable to our team's success (shoutout William!).

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?

These papers were really interesting reads and were relevant to the work we were doing throughout the semester. The principles are very important to consider while designing architectures and class hierarchies.

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

Getters and setters were already quite an ugly practice to me. I tend to avoid them simply due to their lack of elegance. It was good to read about other reasons why you should avoid them when possible.

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

While Git is used widely in almost every CS class here at UT and I had used it before, it wasn't until this class that I felt I truly achieved Git mastery.

What's the most helpful Web dev tool your group used that was not required?

I personally didn't use it, but we used Marshmallow, which is a serializer/deserializer that works with Flask on the backend to allow us to work in Python rather than raw SQL.

How did you feel about your group having to self-teach many technologies?

I felt that it was a great "real-life SWE simulator". I feel that what makes a good software engineer isn't what they already know, rather, the ease with which they learn new technologies -- their adaptability. This was a great way to practice that skill before entering the corporate world.

In the end, how much did you learn relative to other UT CS classes?

In terms of how much I learned, I think this is probably the UTCS class where I've absorbed the most knowledge period. There is just so much required of each individual in this class that it's impossible not to learn an insane amount. Very glad I took it, despite my issues with the specifications grading.