Assignment 1 Code Review

Design

Algorithm design, not program design.
- The key is figuring out the complex portfolio.
- Everything else is relatively simple.
Understand the problem before attempting a solution.
- Understand the problem's background too.
- You have to know about percentages.
You're going to be paid to solve problems, not write code.

The straightforward approach doesn't go far enough.
- Computer D_x = I_x - V_x/V_p
- Add D_x/P_x shares of X to the portfolio.
- Unfortunately, changing V_p changes everything else.
- Work a simple example - it doesn't work.
Compensate for the change in V_p.
- (V_x + B_x)/(V_p + B_x = I_x
- Solve for B_x.
- This works, but it requires constant recalculation.
Work backwards - start with the final portfolio value.
- I_x = (V_x + B_x)/(V_p + M)
- Solve for B_x.
- No iterations, no recalculations, compute three values.

Be as simple as you can to solve the problem.
- Classes are not simple.
I-O is always a pain, but it's important.
- Know the tools you have available.
- Understand how the tools behave.
  - Use the behavior - e.g. parsing doubles.
  - Work around the behavior - e.g. skipping white space.
Use the input structure to guide your design.
- Use string I-O - know the tools.
  - Read a line; read three numbers off the line.
- Use stream I-O - know tool behavior.
  - Read three numbers before end-of-line.
  - Check for end-of-line.
  - Space-eating behavior makes this difficult.

Learn to estimate important values from designs.
- Lines of code in particular.
Program parts.
- Input - Read line, read numbers.
- Processing - Compute the portfolio strategies.
- Output - output portfolio strategies.
Remember: these are estimates.
- They don't have to be correct, or even close.
- Your estimating skill should grow with experience.

Input - without strings.
- Read a double - 3 lines.
- Read three doubles - (3 + 1)*3 lines.
- Skip white space - 4 lines.
- (3 + 12 + 4)*2 = 40 lines of code.
Portfolio processing
- Simple portfolio - 3 lines.
- Complex portfolio - 3 + 7 + 6 lines.
- (3 + 3 + 7 + 6)*2 = 40 lines of code.
Output
- Each Field - 1 line.
- Rounding - 2 lines.
- (1*3 + 2*2)*2 = 14 lines.
Totals
- (40 + 40 + 14)*2 = 200 lines.

Control complexity in your code.
Complexity is anything that's too much or too many.
- Too much nesting.
- Too many lines of code.
- Too many variables.
- Even too many comments.
Learn to recognize complexity and eliminate it.
- Procedures are your friends.
- Too many procedures? - Hide them in files.

Follow the given output format.
- Not
  S: 2500 X :50 Y :30 Z :20 C: 2500 X :50 Y :30 Z :20
- Not
  Strategy S : 33 40 27 7500 Strategy C : 50 30 20 7500
- Not
  s50 30 20 2500 c50 30 20 2500
No prompting!
Please enter stock prices: To Quit Enter Ctrl D Please enter stock prices:To Quit Enter Ctrl D S 50 30 20 2500 C 50 30 20 2500

No files.

Pls specify input file.

Dynamic memory is expensive and uncertain - avoid it.
- Particularly if you don't need it.
  char * string = new char[100]; if (cin.getline(string, 100)) {
If you use it, use it correctly.
- If you allocate it, delete it.
- That string was never freed.

Don't re-invent what you've already got.
- About half the class parsed their own doubles.
- Stream extraction will do this for you.

File Counts	Count	Average Lines/File	Avg Semicolons per File
1	8	315	146
2	1	197	84
3	6	160	61
4	0
5	3	81	35
6	1	84	27
7	3	81	29
8	0
9	0
10	0
11	1	61	18

Figuring out test data for you code is important.
Generating good test data is hard.
- Exploit properties of the problem.
- Exploit properties of the solution.
- Exploit extreme cases.
- Check the common error cases.
- But, simple cases work surprisingly well.
Develop a small test harness for your program.
- Need to be a good shell programmer.
- It doesn't have to be elaborate.
- Code a little, test, code a little, test, . . .
- The effort will pay you back many times over.

Problem properties.
- Multi-month runs with identical values.
  - Portfolio values should be the same.
- Special last-month values.
  - Spend all the money on X to reach 50%.
Solution properties.
- Percentages summing to 100.
Extreme cases.
- Empty input, very big input.
Common error cases.
- Too many numbers, not enough numbers, not numbers.

This page last modified on 12 February 2002.