We did not have the network set up correctly, so we were not able
to look at the prototypes. Instead, we discussed the importance of
prototypes. It is good to bring a working version to the customer even if
it does not offer full functionality. It s hows that work has been done,
and it gives the customer an opportunity to offer suggestions on what he
or she wants. Two groups did actually have prototypes to offer which was
impressive. One group's prototypes supposedly had full functionality.
Instead of covering the date class, Owen covered other important
issues in lecture. There was a handout given out to assist us through the
lecture. The three topics covered were Makefiles, C++ filt, and
inheritance.
For those that were unclear about how makefiles work, Owen cleared up some things. We learned about the significance of some of the odd symbols at the top of makefiles (i.e. $< = target, and $@ = root). I was especially enlightened with the informat ion given on targets and dependencies. One must put certain things before other things in the makefile in order to make compilation faster. If dependencies, are more recent than a target, they must be recompiled. But some things, such as base classes, and classes that you do not change can be placed near the top of the makefile, and they do not have to be recompiled every time a compilation is performed. Owen then showed sample makefiles that he had created to demonstrate his points. I believe that y ou can obtain one of his makefiles by looking in his directory.
The next thing covered was C++ filt. Some students were getting odd errors during compilation. The compiler would feed back a long, mangled mess of letters and refer to them as an error. There is a tool called C++ filt (there is also a tool called de mangle) that one can use to better understand what those errors mean. One only needs to type in the mangled mess given by the compiler and use C++ filt on it. C++ filt will descramble the mess and give the original code. Then you can search for the error.
Lastly, we discussed inheritance. We studied the classic shape example for inheritance where the shapes (like rectangles) are all inherited from a base class called shape. We also learned the use of virual functions and the ability to declare somethin g as pure virtual through the use of =0 right after the member definition in the base class.
Owen then demonstrated his main program code for his version of multigrep. It was highly object oriented, and it only took up a few lines. It appeared as if he had used a class called multi to implement all of the important functions of the program. I never really considered using a class to do the main work of the program. It is an interesting concept, and it is definitely something to think about when writing the multigrep program.
In conclusion, the lecture was informative and important. If you don't understand makefiles and also missed the lecture, you really missed out some important information, and you should talk to someone in the class. The discussion on multigrep and pro totyping was also important and worthy of asking a classmate if you missed it. Otherwise, the rest of the information was helpful, especially to me (I am rusty on my C++), but could be found in the readings if you missed the lecture.