CIT 591 Assignment 10: Drake Equation
Fall 2008, David Matuszek

Purposes of this assignment:

• To make sure each of you has experience creating GUIs
• To give you more experience with exception handling
• To give you more experience with JUnit testing
• To give you some idea of the size of the universe

General idea of the assignment:

Are there really intelligent alien civilizations? If so, how many, and can we ever communicate with them?

The Drake equation supplies the answers to these questions. Your assignment is to develop code to compute two versions of the Drake equation (Drake's, and mine), and to implement three different interfaces to that code.

From the article Drake Equation in Wikipedia:

 The Drake equation states that: N = R* × fp × ne × fl × fi × fc × L where: N is the number of extraterrestrial civilizations in our galaxy with which we might expect to be able to communicate and R* is the [yearly] rate of star formation in our galaxy fp is the fraction of those stars which have planets ne is average number of planets which can potentially support life per star that has planets fl is the fraction of the above which actually go on to develop life fi is the fraction of the above which actually go on to develop intelligent life fc is the fraction of the above which are willing and able to communicate L is the expected lifetime [in years] of such a civilization

However, this is just for our own galaxy.

We will use this equation as is, but we will also introduce a second, modified version of the equation:

 N = G × R* × fp × ne × fl × fi × L

This equation has been modified in two ways. First, I have added the factor G, to represent the number of galaxies in the universe. Second, I have removed the factor fc, on the assumption that, even if life does exist in other galaxies, it is much too far away for us to ever hear their radio signals. N, therefore, is the total of all intelligent civilizations that exist "now", not just those with which we might communicate.

 Some numbers: Astronomers' best estimate of R* is in the range of 5 to 20 per year. Our own solar system has from 8 to 12 or 15 planets, depending on what you want to call a planet. So far we can only detect very large planets in nearby star systems, in most cases just the one largest planet. As of November 2008, we have discovered more than 300 such planets. The number of stars in a galaxy is typically from 107 to 1012, and is about 1011 on average. (This number is not used in the above equations; the rate of star formation, R*, is used instead.) The best estimate for G (number of galaxies in the universe) is 1011. The best estimate for SG (average number of stars in a galaxy) is also 1011. The rest of the numbers are anyone's guess.

Details

Create a package drake with the following three classes in it.

The DrakeEquation class

Write a class DrakeEquation to compute the equations given above. It should have the following setter methods:

Factor Setter method
R*
void setStarFormationRate(long)
fp
void setFractionWithPlanets(double)
ne
void setAverageHabitablePlanets(double)
fl
void setFractionWithLife(double)
fi
void setFractionWithIntelligence(double)
fc
void setFractionWithCommunication(double)
L

(G is not included in this list because its value is reasonably well known, and can be hard-wired into the program.)

The setter methods should throw an IllegalArgumentException (which is a RuntimeException) if they are given illegal values. (All values should be non-negative, and fractions should be less than or equal to 1.) Write JUnit tests for this.

DrakeEquation should have the following getter methods:

Getter method What it returns
double getLifeInGalaxy()
The number of planets in our galaxy that have life:
LG = SG× fp × ne × fl
double getCommunicatingCivilizations()
Result of applying the Drake equation: The number of intelligent civilizations in our galaxy with which we might possibly communicate.
double getLifeInUniverse()
The number of planets in the entire universe that have life:
LU = SG × G × fp × ne × fl
double getIntelligenceInUniverse()
Result of applying the modified Drake equation: The number of intelligent civilizations in the entire universe.

Each of these methods should throw an IllegalStateException (which is a RuntimeException) if they are called before all the variables they use have been given a value. (One way to test for this is to initialize all variables to -1.) Your unit tests should check for this. For other testing, set the input variables, get the output result, and test whether it is correct. You should test whether extreme cases are handled correctly.

The user interface classes:

There are three user interface classes, for reasons that I will explain in a moment. Each of these has a main method, so that the program can be run starting from any one of these classes. Since all of these methods do input/output, do not write unit tests for any of them.

The DrakeTextUI class

This class does text-only input and output. Ask the user for the value of each input factor; if any exception occurs, catch it, print a helpful error message, and tell the user to try again. Use the nextDouble method in java.util.Scanner to do input.

All the getter methods return double values. However, any numbers greater than one and less than Long.MAX_VALUE should be cast to long before printing.

When all values have been input, the values for both sets of equations (our galaxy and entire universe) should be printed out (with explanatory text).

The DrakeGUI class

This class uses a Swing GUI to interact with the user. After all the necessary fields have been filled in, the user can press a button to compute the (original) Drake equation and see the results for our galaxy. All normal interaction should take place in a single (JFrame) window; use dialogs to warn the user of missing (blank) or illegal values.

All the getter methods return double values. However, any numbers greater than one and less than Long.MAX_VALUE should be cast to long before printing.

The program should quit when the user clicks a "Quit" button or closes the main GUI window.

The ModifiedDrakeGUI class

This class uses a Swing GUI to interact with the user. After all the necessary fields have been filled in (not including fc, which is not used), the user can press a button to compute the modified Drake equation and see the results for the entire universe. All normal interaction should take place in a single (JFrame) window; use dialogs to warn the user of missing (blank) or illegal values.

All the getter methods return double values. However, any numbers greater than one and less than Long.MAX_VALUE should be cast to long before printing.

The program should quit when the user clicks a "Quit" button or closes the main GUI window.

Handling exceptions:

All exceptions should be handled. Nobody likes a program that crashes. Some exceptions will come from the DrakeEquation class; others will come from entering non-numeric values when a number is required.

• When the GUI classes, DrakeGUI and ModifiedDrakeGui, receive an exception, they should put up a JOptionPane message dialog to inform the user of the problem. They should also blank out the offending text entry.
• When the text-only class, DrakeTextUI, receives an exception, it should print a message to the user and ask the user to enter a replacement value.

Assignment:

Work together with your partner to complete the DrakeEquation and DrakeTextUI classes. However, each of you should individually write one of the two GUI classes. Both need to be done, so agree with your partner which of you does which GUI (they are of equal difficulty). Be sure to use the @author tag or tags in every class.

My goal is that each of you gets experience constructing a GUI. Please do the initial design and programming by yourself. If you run into difficulties, you can get help from your partner, but first get as far as you can by yourself.

When your GUI is completed, it is a good idea to show it to your partner, to find out whether using it is as obvious as you undoubtedly think it is.

If you have no partner, you can omit the ModifiedDrakeGUI class.

Grading and due date:

Grading will be based on correct functioning, good code style, and reasonable GUI appearance and comprehensibility. In this assignment you and your partner may receive different grades, as each of you has primary responsibility for one of the GUI classes. (Each GUI class should have one @author tag, naming its one author; other classes should have two @author tags, unless you have no partner.)

Due date:

As usual, turn in one zip file for the partnership containing all necessary Java files. Due Thursday, November 20, before midnight.