General Information

Course Home

News

Contacting Us

Syllabus

Reading List

HW, Exams, and Project

Homework

Term Project

Changes

Exercises

Past Exams

Course Policies

Grading Policy

Academic Honesty Policy

Reference

FAQs

Links

Computer Sc.

ISU

Com S 362 - Object-Oriented Analysis and Design (Fall 2007 Edition)

Frequently asked questions about Homework 2-2

Do we use the function given in the homework description to do the multiplication in our implementation?

The function that is provided serves to illustrate how polynomial multiplication ought to be done. You can use part of the code from the function, if you want. Otherwise, feel free to write the equivalent functionality.

Should the input for all implementations be the two arrays?

This is the case for all implementations.

In case of the program design and implementation in a pipe-filter style I mentioned that such implementation could treat the polynomial as a stream of polynomial terms. My apologies for any confusion.

Can I make my own PolynomialMultiplication.java instead of using the one provided?

Please try to use the component provided. Having a common core component (or at least common basic algorithm) will allow us to assign grades for this homework uniformly.

Should we reorganize the core component using the architecture styles, or leave the given core component alone and apply the styles to organize the components (input, output, core, connectors)?

You can go either way i.e. solutions that leave the core component alone as well as those that change it are ok. In particular, for pipe-filter architectural style it may be beneficial to change it to demonstrate functionalities of the filter together contributing to computing the multiplication.

What articles can I reference to ensure I am correctly implementing the three architectures correctly?

The KWIC system was discussed in the context of the information-hiding principle paper by Parnas

KWIC Implemented with Main/Subroutine Architectural Style

KWIC Implemented with Object-Oriented Architectural Style

KWIC Implemented with Implicit-Invocation Architectural Style

KWIC Implemented with Pipe Filter Architectural Style

Frequently asked questions about Homework 1-2

How do I install the ASTView plugin?

To install the ASTView plugin, download the jar file which corresponds to your version of Eclipse. These files can be found at http://www.eclipse.org/jdt/ui/astview/index.php . Once you have the jar file downloaded simply move it to the eclipse/plugins directory. If eclipse is running, restart it and you should be able to use the ASTView plugin. Instructions for running the ASTView plugin can be found at http://www.eclipse.org/jdt/ui/astview/index.php

I have downloaded the ASTView source but it will not compile, what is wrong?

You probably need to download the latest version of eclipse. The current version is 3.3, make sure this is what you are using. If you are still having problems make sure that you have "Eclipse Classic" and not any of the other version.

Where do I start?

The first thing you should do is install the ASTView plugin and try it on a few programs. You do not need to have ASTView installed to make changes to and compile the source, but it is a good idea to become familiar with ASTView's functionality before you begin.

Once you are familiar with the functionality of ASTView, find some part of it's output that you would like to change. Open the source for ASTView and find this output in the source. Make a change to this output and recompile ASTView. Now, your modified output should be displayed. This will ensure that everything is working correctly before you continue.

Once you have verified that everything is working correctly, you can begin learning the structure of the source. You can do this by noting which methods the outputs you are modifying are in, and which objects they are a part of. You can then find other places in which these methods and objects are used. By doing this for several of ASTView's outputs you should quickly become familiar with it's source code.

Do we need to remove any of ASTView's functionality?

No, it is not necessary to remove any of ASTView's functionality, you only need to add the new functionality.

How should we format the XML tag for objects that do not have some property (for a example a method that does not have any modifiers)?

Leave out the property from the tag.

For example, if the method "getWeight" does not have any modifiers, that XML tag would appear as follows:

  <method name="getWeight"
          returns="int"
          constructor="no">
  </method>

For functions that return void, should we have 'returns="void"' or do we leave out the "returns" attribute?

Leave out the returns attribute.

What should we do for a default package for a class, have 'package="default"', 'package=""' or not have it at all?

Leave out the 'package' attribute.

Does the tag '<param>' need a closing tag (</param>)?

No, '<param>' does not need a closing tag. However, the '<param>' tag should end with />, which closes the tag.

  <param name="weight" type="int" />

Do we need to have an XML header in our output file?

It is OK to add an XML header, but it is not required for this assignment.

How should we format the XML tag for objects that have more than one instance of a property?

Duplicate the property attribute. This is not valid XML, but for this assignment, it is OK.

For example, if a method has both the public and static modifiers, the tag would appear as follows:

  <method name="getWeight"
          modifiers="public"
          modifiers="static"
          returns="int"
          constructor="no">
  </method>

Frequently asked questions about the class

How can we reduce the scope of our project?

We are looking at our use case scenarios, but the scope of the individual scenarios are too big for us to handle in the course of this semester without killing ourselves. What do we do now ?

Answer: Revisit your use cases, perhaps the requirement analysis conducted was not detailed enough to allow you to correctly estimate the time required to implement these use case scenarios. This happens all the time in real life software projects, where a lot is promised by the analysts to the client. When it comes to design and implementation of the project, and approximate costs of providing the promised functionality become more clear, requirements are renegotiated in the light of these new findings. Here I am your client, so if you would like to reduce the scope of your project by revisiting your use case scenarios, by perhaps splitting a scenario that was intially very complex, send me a new use case as a team.

How can I earn extra credits in this class?

There will be extra credit problems in homework and exams.

Will the project be coded in Java?

Yes, the language we will use in this class is Java.

Shall we decide about the enabling technology right now in inception phase?

No, there is no need to make the decision about the enabling technology in the inception phase. An important design principle is that you should delay every design decision, such as selection of implementation technology, until you absolutely have to take it. Every design choice that you make limits your choices with respect to other design decisions.

|