Week 7

Class:
This week started off with a much needed explanation of the deque project. Many of the students in the class were freaking out because after spending some time looking at the skeleton code they felt some of the code looked foreign and could use some clarification. We spent Monday walking through the STL vector and how it was implemented. This proved to be an excellent exercise as I had made sure to take lots of notes while the professor talked about every aspect of vector. The week continued as we discussed some of the other C++ data structures that used containment to get their work done. Structures like stack, queue, and priority queue are all backed by either vector, deque, or list and we explored the possible Pros and Cons of using each backing structure over the other. The week ended off with some performance boosting information on making functions faster by declaring them as structures and sending into the higher order function an instance of the lower order function.

Project:
Deque proved to be extremely challenging in the short amount of time that we had. My partner and I got to an early start over the weekend and came up with some really novel ways to approach the deque project. After stepping on toes and bashing out some early implementations of our ideas we realized we were going nowhere. Luckily in Mondays lecture the professor dropped a small hint. "Implement a stupid version of deque that uses a single resizing container and write all the methods in a way that passes the buck to just a few key methods in Deque and get that to work, then you can build the version that will give you credit." Although my partner seemed reluctant, worrying that implementing the stupid solution would take too long, I pushed ahead and made the stupid version literally in 5 hours and had it up and running. Now that I felt confident in my understanding of deque, and my partner felt confident in me, we were able to quickly push through finishing up deque together having only to rewrite just a few special methods to make the magic happen.

Week 6

Class:
This past Friday was our exam in the class and I'm really annoyed... Not with the exam, or the format, but with myself for not being as prepared for it as I would have liked. This class for whatever reason has made me super competitive and I was really counting on making a high score on this exam to solidify my rank/standing in the course. So basically I spent WAY more time prepping for the software engineering exam (same day) as I did for this exam and now I really regret it. As I mentioned, the exam wasn't too difficult, nor did it cover material that was completely unexpected. I just wish I would have studied class structures a little better before the exam. The exam format was definitely an upgrade from previous years where we were asked to choose the correct output (multiple choice) after reviewing some code similar to our quizzes. This time the entire exam was like a giant test suite that you could put in a C++ file and actually compile and run. The idea was to code up some solutions to the methods the professor asked us to write and then write test cases for those methods. One of reasons why I like this new format is because even if you don't know how to code a solution, you could create test cases for it and gain some quick points. Furthermore the exam actually prepared you for a real life career choice. If you walked away from this exam with the majority of your points on the exam coming from writing test cases, then this may indicate that you are better suited for a Software Development Engineer in Test role rather than a Software Development Engineer role. Anyways, I learned my lesson and will definitely need to hop on studying for the next test WAY ahead of schedule to get as close to that A grade as possible.

Project:
Not happy about our next project at all. For starters, we only have one week to complete the project as the professor released the project just a few days before the exam. Given that I am in both classes, I had two exams to study for which meant having to prioritize the exams over the projects. As a result I began working on the new project on Saturday. After spending several hours trying to wrap my head around the code I realized the task of implementing the standard library version of deque would not be as easy as BigInteger. There seems to be far less direction on this project. Furthermore, the test suite was of no help. It contains only two test cases and provided no hints as to how to implement the deque. Given the time constraint of one week I expected there to at least be a solid set of test cases given to us. Regardless the professor has informed us that he will be going over the project again in class on Monday. Lets just hope we get enough direction to get it completed by Thursday.

Week 5

Class:
This week was once again a short week since there was no class this past Friday due to final exams for first session classes. We continued to stress function templates and generics which were meant to assist us with the Big Integer project we were working on. I was very happy to see the professor give the class insight on setting up an eager cache within the multiplies_digits function and also give us a templated version of the power function. The BigInteger project was a great way to get exposed to objects and classes in C++ and I hope the trend continues as I am looking forward to learning more specifically about the object oriented qualities of C++ including class extension.

Project:
The BigInteger project turned out to be a big pain... But not for the same reasons it was for everyone else in class. Piazza was peppered with questions about implementation details and students hunting down mysterious bugs. Im happy to report that since my partner and I had started the project earlier, we had plenty of time to carefully optimize and think through every function and not run into serious bugs. For students that had embraced the idea of code first, test later, this week proved to be hell. The problem we had was that our code worked just fine... without any problems... just painfully slow. Wednesday night my partner and I toiled for many hours in the 3rd floor lab trying to wrap our heads around the karatsuba method which we felt would help us speed up our program. To our disappointment it was slowing us down even more. Luckily the professor had released the templated Power function which allowed us to bring our time down to within an acceptable time as per project requirements allowing us to ditch karatsuba. Even though we got the bonus points, I was really upset with the performance of our solution and stayed up till 3AM Thursday night after turning in the project. I reworked most of the project and produced an informative post in Piazza to guide other students that were stuck with the same problem. Its definitely a good read and explains how karatsuba should really be used to make things way faster.

Week 4

Class:
This week was slightly more challenging. For starters, the professor revealed the latest project and spent a good amount of time explaining it on Monday. My concern is that this may have forced him to cover more material on Wednesday than consumable by the students. Usually every slide is designed to convey a few specific ideas in a well organized manner. This time the slides on Wednesday left a lot to digest. My assumption is that the long weekend and the need to explain the project may have eaten into the time required to drill in the concepts presented on Wednesday. I would have to say my single largest weakness with C++ is the organization of the files. In java its pretty straightforward: everything is an object, every object can have a main function, then there are interfaces blah blah blah... The point is that it doesn't usually matter where in the file functions are defined ie there isn't much order. This story changes in C++. The professor mentioned that since C++ uses a multipass compiler, it builds its understanding of the program over several passes and with each pass it learns something else. Im not quite sure I understand this and I hope the professor gets to spend some more time on it tomorrow.

Project:
The BigInteger project is pretty cool. It is very similar to the matrix project that is usually presented in the OOP class. The idea is to implement our own class from bottom to top. I didn't make the same mistake I made last time by starting late. This time I was quick to get a partner and hop to it. We were able to blow through some of the first functions with ease but the plus_digits and minus_digits required a little extra work. After some toiling on the white board we were able to put together some really efficient code while sticking to the original project parameters. Im glad we got a head start. My partner revealed that some of his friends haven't started yet and that they may be making a huge mistake underestimating the difficulty. My partner and I still need to swing by office hours tomorrow to figure out how to make some of the functions we have coded more generic. If you haven't started yet... good luck, its gonna be a long week.