CS373 and CS378 Blog @lydiashn-blog - Tumblr Blog

CS378 Week Ten

Last blog post...here goes.

So Friday's test seemed far too long. The material covered wasn't particularly difficult for me as I looked through the test and felt I had a good understanding of how to complete each of the questions. However, having to write "typename" about 50 times does eat away at the time we're given for the exam and doesn't really help me get much closer to showing that I know the solution to a problem. The material covered was varied and fairly covered the topics we went over in class. There was just too much writing. In addition, the omission of key standard library features we could use to solve certain questions until much later into the testing period hurt quite a bit as you would just sit there thinking about how to solve an problem without a few key functions. I really can't help but think that had I just 15 more minutes I would have been able to get all my ideas down on paper. In the future, it might be helpful to say that various std features can be abbreviated or certain tedious parts of the syntax omitted.

Looking back over this summer session, I can now confidently say that I am most definitely more comfortable with C++ than I was before. Thus, this class has been of great value to me. C++ was always one of those language that I had intended to learn on my own time but never got around to, so taking this class in a sense forced me to do something I had been putting off for quite a while. I'm quite glad I decided to take this class in addition to CS373 this summer and I definitely feel like a much better programming for it.

CS373 Week Ten

I felt like the last test covered a good variety of the material we learned following the second test. Although the UML diagram material felt like it should have been covered on the second test instead of this one. The test was a pretty good length and I felt like the refactoring questions were fair, especially if you had a good cheat sheet.

Overall, I've enjoyed taking this class this summer. I definitely think that the skills I've learned, especially using Git and issue trackers, will be valuable to me in the future. Also, it's made me much more familiar with Python which I had no experience with prior to this class. I'm extremely glad I decided to take this class over the summer as I was able to focus on them more without needing to worry about a bunch of other classes at the same time. It really gave me adequate time to learn the tools and understand the material.

CS378 Week Nine

This week we went over iterator traits. It's interesting to see that so much of these iterators just involve one method completing everything and most of the other methods just return a reference to the current object. There's only one week of class left. I'm feeling rather confident going into the test on Friday based on the material covered since the last test. Hopefully nothing too unexpected will show up before then.

CS373 Week Nine

This week we began going over the material covered in the Refactoring book. Most of this material seems like common sense, and it seems rather unnecessary to assign formal names for all of these techniques. However, I guess it is useful if you have to document and describe the changes that you've made to code, but I feel as if I end up automatically correcting these things when I'm initially writing code.

We also started with presentations this Friday. Overall, I think the two groups that presented on Friday, A and E, did the best job with the project so it was interesting to see what they ended up doing with their import/export and UI. Our presentation is tomorrow so hopefully it goes well.

CS378 Week Eight

I spent most of my time this week working on the Graph project. It turned out to be much simpler than I expected since we didn't have to worry about templating and memory management was handled by the STL containers. Testing was a bit difficult since the entire graph needed to be constructed to test various functions and much of the testing of certain methods were based upon other methods working.

The lectures are beginning to cover material that was covered in CS373 some weeks ago. However, it's interesting to note the differences between C++ and the languages used in the other class.

CS373 Week Eight

This week we continued work on the third phase of the world crises project. I helped with the visual redesign of the UI on the appspot and worked to rewrite and reformat the technical report. The project is coming together nicely. At this point the only things we have left to do it some browser compatibility on the website as well as some cosmetic changes, and the technical report. We're adding many more diagrams and pictures to demonstrate ideas stated in the technical report to make everything clearer. In addition, our site now handles unicode which is an interesting and unique feature that Peter implemented.

CS378 Week Seven

I felt much more prepared for this week's test than the last one because I was definitely more comfortable with C++. The test overall had a good variety of topics tested and length. I also liked how it was programming questions rather than book questions. I'm still kicking myself over having changed by answer to the iterator question after looking at the given definition of the input iterator since I had originally said that it required a forward iterator, but I probably got more points from double checking my work than I lost for changing that answer so everything should work out in the end.

CS373 Week Seven

Going into Friday's test I expected it to be like the first exam, so much of my cheat sheet was over the Database Design book. However, most of the test was programming questions which is actually a format I prefer more, but since the last test so heavily based on book questions, I overstudied that material. I also felt like it was rather unfair that the first few programming questions all required knowledge of the * packager. Not knowing that one thing should not have resulted in losing points over multiple questions. Overall the test was a good length and had good coverage over the variety of topics we covered in class.

CS378 Week Six

The Deque project is coming along nicely so far. I feel like I am understanding much more about how to work with the allocator and I find myself getting less confused when it comes to keeping track of pointers. It still annoys me that the difference of an iterator to the start and an iterator to the end creates a size_type that can't be used as an ending condition on a for loop, forcing me to make while loops everywhere. However, this is simply a small complaint. Making the structure circular will be tricky though since many of our methods rely upon some intricate math using the beginning and end pointers we've created. My partner and I will have to mull over the solution some more if we have time before the deadline tomorrow night.

There is also a test on Friday. I'm feeling better about this test than did about the last one since I feel like I'm not as lost during the lectures now that I'm more familiar with C++. It might all just come down to making a really good cheat sheet.

CS373 Week Six

This week's lecture covered map and reduce. I still vaguely remember having to program some form these in Java in CS315, so it wasn't that difficult to understand them in class. It was a very interesting point that was made about the importance of testing rather than just relying on big O analysis with map and reduce being faster in both Haskell and Python since they were built in already.

The project due tomorrow is the second phase of world crises. My main responsibility is to write the technical report. It's really forcing me to get a better idea of what the rest of my group has done for the rest of the aspects of the project.

There is a test on Friday. I feel rather unprepared for it in terms of the readings, but I should be fine for the programming as long as I take the time to figure out what the Haskell examples are talking about.

CS378 Week Five

This week we spent most of our time working on Integer. Working through this project I realized how very important it is to find real solutions to problems rather than inefficient quick fixes. Due to time constraints, I ended up making a lot of inefficient extra copies in the basic methods that later compounded to be an even greater problem in the later more complex methods that built off of the simple ones. I have to remember to get started earlier on this next project.

CS373 Week Five

We didn't really have much class this week, so I'll probably be talking mostly about the World Crisis project. I still wish the specifications were more well defined, and we had some issues with the submission format because we weren't aware that Arun simply edits his original submission instruction post instead of posting new ones.

Arun chose group E's schema. Since our schema was not based off of the common one used by the other groups, we will likely have to rewrite much of our code in addition to the new tasks for phase 2.

CS378 Week Four

The project due next week that we've been working on for the majority of this week is Integer. So far our shift_left_digits and shift_right_digits work properly. plus_digits works for most cases including cases where the two inputs are different lengths, but it currently breaks when the most significant digit has a carry. It breaks because the carry causes an overflow past the x that is passed in as the start of the output container. We are working to fix this by shifting all the digits to the right and assigning the most significant digit to 1. Although currently it does not give the correct output. The rest of the methods should be relatively easy after we figure out the general procedure for plus_digits.

CS373 Week Four

On Friday, we talked about function generics. This seems like an extremely useful tool for defining operations that need to be used for multiple types. Although this seems excessively complicated to implement in Java, for the other languages, especially Python, it seems like something I would end up using a lot. Also, I'm kind of lost as to what to do for the World Crisis project. I really wish there was better documentation for what was required online. However, so far, our group is making good progress on the project despite the rather fuzzy parameters.

CS378 Week Three

The main thing for this week was the first test on Friday. Overall, the test was short and simple.

The short answer questions were easy, and I'm glad there weren't super specific questions from the book which was something I was dreading while studying for the test.

I'm pretty sure my answers to the final two questions were wrong since when I start thinking about pointers and references, I always get mixed up and second guess myself. As far as that goes, I am certain that more practice with C++ will help me feel more comfortable with it.

CS373 Week Three

The big thing this week was the test on Friday. Overall, my impressions of the test were that it seemed awfully short and that it didn't end up covering a lot of the topics that we've gone over.

I felt like the questions over the XP book were very all or nothing. Either you knew what they were talking about or you didn't and for a problem that's work a good chunk of points it was kind of a scary thought. If anything, I would have preferred more questions over code like the ones given on the quizzes.

Also, I was kicking myself after the test for not writing down an in-depth Haskell example just so that I could know the proper formatting. It's frustrating when you know how to implement something but can't write it correctly in a language that you're uncomfortable with.

CS378 Week Two

Between the reading and the lecture topics, I'm really starting to realize a lot of the differences between Java which I'm very familiar with at this point and C++ which I am learning as I go for this class. In particular, the way that both languages deal with arrays is quite different and I often feel myself getting frustrated by the fact that arrays in C++ can't just be like arrays in Java. Although that's just because it's so much easier to use what you're familiar with than to learn something new.

The programming project for this week is to write a program that solves the stable marriage problem. In the end, instead of using arrays and having to worry about pointer errors, we settled on a solution that used vectors and stacks. And thankfully, unlike our Python solution for CS373, even the cubic version was accepted by Sphere under the time limit. I feel like I'm only beginning to develop a healthy hatred for segfaults.

Trending Blogs

Recently Viewed Blogs

CS373 and CS378 Blog