CSE143 Winter 2003

Project 0

Does Luck Know Your Name?

An Experiment in Computational Theology

Please read the following turn-in forms carefully, including the fine print!  After submitting a form, read what comes back, too. PLEASE make sure that you use the correct form for each part!!

Part A Turn-in form. 

Part B Turn-in form

Due dates: Part A (electronically): 9:00 pm Friday, Jan. 10; Part B (electronically): 9:00pm Monday, Jan. 13; paperwork for both parts: beginning of quiz section, Tuesday, January 14.  ["Paperwork" will always mean the printed electronic receipts, plus any written material (questions, diagrams, etc.) that might have been assigned.  Staple all such material together, please.]

When you cross your fingers, or say "wish me luck", you're invoking the god or goddess of luck, at least metaphorically.  But does that deity even know who you are?  Let's find out, using the latest tool of experimental theology: the computer.

Here's the idea.  If you pick a letter at random, it might be the first letter of your first name.  That would be a clear sign that you have Luck on your side.  If the letter you pick is not your initial, pick at random again.  Keep picking if necessary.  Eventually you might expect to draw your initial, unless the gods really hated you.  The sooner you draw your initial, the luckier you are. 

To make the sign from the gods even more definite, we'll draw two letters at once, and see if they match your first and last initials.  The fewer times you have to pick before the match, the more affection Luck has for you.  Each random letter is picked from the full set of 26 uppercase letters.  Each pick is completely independent.  If your first pick is "A", for example, that has no effect on how likely "A" is as the next pick.   If a pair of letters doesn't match your initials, we throw away both letters and draw another pair.

To implement this is Java, we have designed three classes.  You will need to read through the program code and comments carefully.  It will have information that is not in this write-up.   Your job will be to add code to make a Luck Tester.  With it, you and your friends can have hours of fun determining who you among you is truly the luckiest.

The classes are:

• P0Main.  This class is given to you in full.  Don't modify it, since you won't be able to turn it in.  We will use this version of P0 main for testing the code which you do turn in.
• LuckTester.java.  This class has methods which test how lucky you are and interprets the results.  You will have to complete the code for this class.  As clues to what to do, read the comments in the code carefully, and study the main program to see how it uses the LuckTester methods.
• CharGenerator.  This class has methods for randomly choosing characters and testing them for appropriateness.    You will have to complete the code for this class.  As clues to what to do, read the comments in the code carefully, and study the other classes program to see how they use the CharGenerator methods.

Written part

• I. This project consists of several classes and methods. Draw a diagram or diagrams to show how these parts are related.  We will be talking about various forms of diagramming as the course continues.  For now, use your own notation or something you learned from the book or elsewhere; be clear and reasonably complete; keep it to one page.  If your answer shows effort and understanding -- that's sufficient.  And that's all we're going to say about it!
• II. The keywords static and final are used in the code you are given as a starter.  For each instance where the words are used, explain a) what the keyword means in that particular situation, and b) whether it could be omitted. [One way to give your answer would be to print off the code and write directly on the page.]

Some rules (for this project):

• You may not change the package name, class names or qualifiers, or any method signature (method name, qualifiers, return types, parameters, etc.). 
• You may not define additional .java files.  
• You are free to add methods, constructors, instance variables, etc. or to overload existing methods, if they help you solve the problem.
• This project is to be done by each student individual, with no code sharing or code viewing.

Some advice:

• Keep it simple.  You won't get extra points for being complex or elaborate (although you might win your TA's admiration, or mine!). 
• Read the assignment through carefully, word for word, before beginning to work.
• Read the assignment through carefully, word for word, before turning in the program. 
• Study all the code, away from the computer at first.  Don't be distressed if some of the code doesn't make perfect sense.  One fact of life when working with complex systems is that you won't always understand everything -- and yet you still must make your part of it work!
• Use the Message Board to ask questions -- or to answer them if you have something figured out.  Just don't post any actual code, please.
• Finally, don't be distressed or disappointed if this assignment strikes you as too simple or too constrained.  There will be more complex assignments later on.  And even in a simple, constrained task like this, some people will still find ways to be creative.

What about style?  Style and programming practice are taken seriously in CSE143.  We'll have much more to say about those topics as we go along.  For now, just use your best style, as you understand it.  We will look mainly to see that you are making a conscious and reasonable effort to be clear and consistent.  The basic philosophy is that a program must communicate well to a human reader as well as to a computer.

What about efficiency? Don't worry about it -- really!  Make the code correct and straightforward, and it will be efficient enough for now.  We will talk about efficiency in technical terms as the course progresses.

Part A specifics: Turn in the two classes, such that they compile without error on the turn-in server, and such that the resulting program executes without blowing up.  The program does not even have to produce any sensible output, or really do anything at all!  Do the minimum possible.  The entire focus is on the mechanics of Java and using the tools for building and turning in programs.

Part B specifics: Turn in the two classes again, such that the resulting program, executed on our servers, operates correctly.

A major goal of this project is to ensure that you have your computing environment set up properly, or can use the environment in the IPL successfully.  If the program compiles on your computer and not on ours when you turn it in -- then you're out of Luck (so to speak).  Find the problem and fix it, and turn in again.  (Of course, another goal of Project 0 is to make sure we have the course software and turn-in programs working properly!  There could be glitches...)

Notes on running from the command prompt.  Once the program is compiled, you can run it from a Windows command prompt.

• To open a command window, choose Run from the Start menu, and type cmd (on olderWindows systems, type command).
• You should get a command window, in some default directory.  Change to the directory just above the package directory.  For Project 0, the package is named project0, so the the .java and .class files should be in a directory named project0; change to the directory which contains project0.
• Type java followed by the starting (main) class name.  In our case, this will be project0/P0Main.  Follow this by an command arguments.  For Project 0, this is a string with two letters.  Don't forget "" around the argument strings.

For example, on my home machine, my project directory is C:\Documents and Settings\dickey\My Documents\MDJava\143-03wi-projects\poStarter\project0, so I open a command window with cmd, then change to C:\Documents and Settings\dickey\My Documents\MDJava\143-03wi-projects\poStarter.  Then I type java project0/P0Main "MD".  The last time I tried this, the result was:

Just my luck, so to speak.  Maybe yours will be better.