HARDWARE ADVANCES MOORE’S LAW: COMPUTER POWER (CIRCUITS PER CHIP) DOUBLES ABOUT EVERY 18 MONTHS.
-
Upload
harold-singleton -
Category
Documents
-
view
216 -
download
1
Transcript of HARDWARE ADVANCES MOORE’S LAW: COMPUTER POWER (CIRCUITS PER CHIP) DOUBLES ABOUT EVERY 18 MONTHS.
SOFTWARE CRISIS:
1. DEVELOPING PROGRAMS TO
UTILIZE THE GREAT HARDWARE
2. CHRONIC SHORTAGE OF
COMPUTING PROFESSIONALS
PRINCIPLE OF ABSTRACTION
WHEN TRYING TO SOLVE A PROBLEM,
SEPARATE WHAT IS TO BE DONE
FROM HOW IT WILL BE DONE.
THIS GENERALIZES THE PRINCIPLE OF DATA
ABSTRACTION: SEPARATE WHAT A CLASS DOES
FROM HOW THE CLASS IS DEFINED.
1. FUNCTIONAL SPECIFICATIONS
EXPLICITLY DESCRIBE THE
BEHAVIOR (THAT IS, INPUT
AND OUTPUT) OF THE PROGRAM.
FOR EXAMPLE:
TO REPLACE STRING X WITH STRING
Y, THE FORM IS %X%Y%. IF THE %
DELIMITER OCCURS FEWER THAN
3 TIMES, THE ERROR MESSAGE IS
*** ERROR: THE DELIMITER MUST
OCCUR THREE TIMES. LINE IGNORED.
SHOULD THE PROGRAM ATTEMPT
TO DETECT ALL INPUT ERRORS?
THAT DECISION IS MADE BY THE
CLIENT: THE PERSON WHO IS
PAYING FOR THE PROGRAM.
2. SYSTEM TESTS ARE CREATED TO
REINFORCE AN UNDERSTANDING
OF THE PROBLEM AND TO PROVIDE
DATA FOR TESTING THE
COMPLETED PROGRAM.
System Test 2: (input in boldface)
Please enter the mean arrival time: 5
Please enter the mean service time: 4
Please enter the maximum arrival time: 20
Time Event Waiting Time 6 Arrival 7 Departure 0 12 Arrival 17 Arrival 18 Departure 0 19 Departure 1
The average waiting time was 0.3 minutes.The average queue length was 0.1 cars.The number of overflows was 0.
I. STAGE II. PROGRAM DESIGN
WHAT CLASSES WILL I NEED?
WHAT METHODS WILL I NEED?
WHAT FIELDS WILL I NEED?
SOFTWARE DEVELOPMENT LIFE CYCLE
AFTER INDIVIDUAL CLASSES HAVE
BEEN DESIGNED, DETERMINE
CLASS-TO-CLASS RELATIONSHIP AND OBJECT-FIELD TO CLASS RELATIONSHIP
CLASS-TO-CLASS RELATIONSHIP Employee Company
HourlyEmployee Company2
USE FROM SUBCLASS TO SUPERCLASS
OBJECT-FIELD TO CLASS RELATIONSHIP:
WHEN THE CALLING OBJECT IS
DESTROYED, SHOULD THE OBJECTS
REFERENCED BY FIELDS ALSO BE
DESTROYED?
COMPOSITION: WHEN THE SPACE
FOR THE CALLING OBJECT IS
DEALLOCATED, THE SPACE FOR
THE OBJECTS REFERENCED BY
FIELDS IS ALSO DEALLOCATED. name DEPENDS ON Employee OBJECT
HERE IS AN EXAMPLE IN WHICH THE
SPACE FOR THE OBJECT
REFERENCED BY A FIELD IS
NOT DEALLOCATED EVEN AFTER
THE SPACE FOR THE CALLING
OBJECT IS DEALLOCATED:
AGGREGATION: THE SPACE ALLOCA-
TED FOR y’S OBJECT SHOULD NOT BE
DEALLOCATED WHEN THE SPACE FOR
THE CALLING X OBJECT IS DEALLOCA-
TED. WHY? BECAUSE THE ADDRESS OF
y’S OBJECT WAS RETURNED FROM
sendIt.
TESTING IS NOT PERFECT:
1.IF NO ERRORS ARE FOUND, THAT
DOES NOT IMPLY CORRECTNESS;
2.THE TESTER MIGHT BE BIASED IN
FAVOR OF THE METHOD.
HOW CAN WE EXTENSIVELY TEST
METHODS IN CONCERT?
DRIVER: A PROGRAM SPECIFICALLY
WRITTEN TO TEST THE METHODS IN
A CLASS
TYPICALLY, A DRIVER WILL HAVE
ONLY TWO LINES OF INPUT: THE
INPUT-FILE PATH AND THE OUTPUT-
FILE PATH. FOR EXAMPLE:
linked.in1linked.ou1
EXERCISE: LinkedDriver, WHICH IMPLEMENTSProcess, HAS THE FOLLOWING DEFAULTCONSTRUCTOR:
public LinkedDriver() {
myLinked = new LinkedCollection( ); lineRead = 0; gui = new GUI (this); gui.println (IN_FILE_PROMPT);
} // constructor
AFTER THE INPUT-FILE PATH AND OUTPUT-FILEPATH HAVE BEEN READ IN, readAndProcessInfile( )IS CALLED.
PUT THE FOLLOWING STATEMENTS IN ORDER.
s CAN BE EITHER AN INPUT-FILE NAME OR AN
OUTPUT-FILE NAME:
public void processInput (String s) {if (lineRead == 0) {else if (lineRead == 1) {fileWriter = new PrintWriter (new FileWriter (s));fileReader = new BufferedReader (new FileReader (s));lineRead++;gui.println (OUT_FILE_PROMPT);readAndProcessInFile();} // output-path line} // input-path line} // method processInput
EXECUTION-TIME REQUIREMENTS
NUMBER OF STATEMENTS
EXECUTED IN A TRACE OF THE
METHOD, GIVEN AS A FUNCTION OF
n, THE PROBLEM SIZE.
FOR EXAMPLE, IF THE METHOD IS IN
A COLLECTION CLASS, n
REPRESENTS THE NUMBER OF
ELEMENTS IN THE CALLING OBJECT.
GIVEN A PROBLEM OF SIZE n, A
METHOD’S worstTime(n) IS THE
MAXIMUM NUMBER OF STATEMENTS
EXECUTED IN A TRACE OF THE
METHOD.
SIMILARLY, A METHOD’S
averageTime(n) IS THE AVERAGE
NUMBER OF STATEMENTS EXECUTED
IN A TRACE OF THE METHOD.
MAXIMUM AND AVERAGE ARE OVER
ALL POSSIBLE TRACES OF THE
METHOD, FOR ALL POSSIBLE FIELD,
PARAMETER, AND INPUT VALUES.
DEFINITION OF BIG-O:
LET g BE A FUNCTION THAT HAS NON-
NEGATIVE INTEGER ARGUMENTS
AND RETURNS A NON-NEGATIVE
VALUE FOR ALL ARGUMENTS.
WE DEFINE O(g), THE ORDER OF g,
TO BE THE SET OF FUNCTIONS f
SUCH THAT FOR SOME PAIR OF
NON-NEGATIVE CONSTANTS C and K,
f(n) <= C g(n) FOR ALL n >= K
IF f IS O(g), f IS EVENTUALLY LESS
THAN OR EQUAL TO SOME
CONSTANT TIMES g. SO g CAN BE
VIEWED AS AN UPPER BOUND FOR f.
IF f IS O(g), WE SAY THAT O(g) IS AN
UPPER BOUND OF f. SIMILARLY, TO
SAY THAT O(g) IS THE SMALLEST
UPPER BOUND OF f MEANS THAT f IS
O(g) AND FOR ANY FUNCTION h, IF f IS
O(h), THEN O(g) O(h).
FOR THE f IN THE ABOVE EXAMPLE,
O(n3) IS THE SMALLEST UPPER BOUND
OF f.
NOTE THAT
O(n3) = O(n3 – 5) = O(4n3 + 3) O(n4)
OFTEN, THE UPPER BOUNDS AND
SMALLEST UPPER BOUNDS WILL BE
FROM THE FOLLOWING SEQUENCE
OF ORDERS:
O(1), O(log n), O(n), O(n log n), O(n2)
IN FACT, WE COULD ARRIVE AT THE
O(n) ESTIMATE WITHOUT COUNTING
THE NUMBER OF STATEMENTS
EXECUTED. BECAUSE O(3n + 1) =
O(7n – 4) = O(12n + 83) = O(n), ALL WE
NEED TO COUNT IS THE NUMBER OF
LOOP ITERATIONS!
EXAMPLE 3:
for (int j = 8; j < n – 3; j++) {
gui.println (j * j);if (n / 2 > j)
gui.println (j * n);
} // for
THE NUMBER OF STATEMENTS
EXECUTED IS … WHO CARES?
THE NUMBER OF LOOP ITERATIONS
IS n – 11, SO worstTime(n) IS O(n).
AND THE CONSTANT 11 IS
DISREGARDED IN THE BIG-O
ESTIMATE, SO ALL THAT MATTERS IS
O(number of loop iterations).
EXAMPLE 4.
for (int j = 0; j < n; j++) for (int k = 0; k < n; k++) gui.println (j + “ “ + k);
HINT: CALCULATE
O(number of inner-loop iterations).
IF n IS NOT NECESSARILY A POWER
OF 2, SOME DIVISIONS, SUCH AS 17 / 2,
WILL REDUCE n BY SLIGHTLY MORE
THAN HALF, SO THE NUMBER OF
HALVINGS WILL BE SLIGHTLY LESS
THAN log2n.
SPECIFICALLY, FOR ANY POSITIVE
INTEGER n, THE NUMBER OF
DIVISIONS BY 2 TO GET FROM n TO 1
IS floor(log2n) – SEE EXAMPLE APP1.2.
WHERE floor(x) RETURNS THE
LARGEST INTEGER <= x.
THE worstTime(n) IS floor(log3n).
SO worstTime(n) IS O(log n), AND THIS
IS THE SMALLEST UPPER BOUND.
EXERCISE: DETERMINE THE
SMALLEST UPPER-BOUND
ESTIMATE OF worstTime(n) FOR
THE FOLLOWING FRAGMENT:
while (n > 5){
gui.println (n);n = n / 12;
} // while
EXAMPLE 7.
for (int j = 0; j < n; j++)gui.println (j * j);
while (n > 1) n /= 2; // same as n = n / 2;
IN GENERAL, IF worstTime(n) IS O(g)
FOR ONE PART OF A METHOD, AND
O(h) FOR THE REST OF THE
METHOD, worstTime(n) IS O(g + h) FOR
THE ENTIRE METHOD.
IF WE KNOW THAT THE SMALLEST
UPPER BOUND OF worstTime(n) IS O (1),
WE WILL SAY “worstTime(n) IS
CONSTANT.”
IF WE KNOW THAT THE SMALLEST
UPPER BOUND OF worstTime(n) IS
______, WE WILL SAY “worstTime(n) IS
______.”
O(1) … constantO(log n) … logarithmic in nO(n) … linear in nO(n2) … quadratic in n
SOMETIMES WE PROVIDE AN UPPER
BOUND BUT NOT THE SMALLEST
UPPER BOUND. FOR EXAMPLE,
// Postcondition: the array a has been sorted// into ascending order. The// worstTime (n) is O (n * n) and// averageTime (n) is O (n log n).public static sort (int[ ] a);
AN ALTERNATE IMPLEMENTATION
MIGHT DO BETTER: worstTime(n)
MIGHT BE O(n log n).
THE ORIGINAL IMPLEMENTATION IS
VERY FAST, ON AVERAGE, IN
EXECUTION SPEED.
METHOD-ESTIMATE CONVENTIONS:
1. n = NUMBER OF ELEMENTS INTHE COLLECTION.
2. IF NO ESTIMATE OF worstTime(n)GIVEN, worstTime(n) IS CONSTANT.
3. IF NO ESTIMATE OF averageTime(n)GIVEN, O(averageTime(n)) =O(worstTime(n)).
TO ESTIMATE A METHOD’S RUN TIME,
// Postcondition: the number of milliseconds from// January 1, 1970 till now has// been returned.public static long System.currentTimeMillis( );
long startTime, finishTime, elapsedTime;
startTime = System.currentTimeMillis( );
// Perform the task:…
// Calculate the elapsed time:finishTime = System.currentTimeMillis( );elapsedTime = finishTime - startTime;
IN MULTIPROGRAMMING
ENVIRONMENTS, SUCH AS
WINDOWS, ELAPSED TIME IS A
VERY CRUDE ESTIMATE OF RUN
TIME.
GIVEN A COLLECTION OF NUMBERS,
A NUMBER IS SELECTED RANDOMLY
IF EACH NUMBER HAS AN EQUAL
CHANCE OF BEING SELECTED. A
NUMBER SO SELECTED IS CALLED
A RANDOM NUMBER.
THE METHOD nextInt( ) IN THE Random
CLASS RETURNS A “RANDOM” int.
THE VALUE RETURNED IS NOT REALLY
RANDOM: IF YOU LOOK AT THE
METHOD DEFINITION, YOU CAN
CALCULATE THE RETURN VALUE.
THE VALUE CALCULATED BY nextInt( )
DEPENDS ON THE SEED. seed IS A long
VARIABLE IN THE Random CLASS
Random random = new Random (100);// initializes seed to 100
Random random = new Random( );// initializes seed to System.currentTimeMillis( )
THE CURRENT VALUE OF seed
DETERMINES THE NEXT VALUE OF
seed, AND THIS IS USED IN
CALCULATING THE VALUE RETURNED
BY nextInt( ).
Random r = new Random (100);for (int i = 0; i < 10; i++)
gui.print (r.nextInt() % 4 + " ");
EACH TIME THIS SEGMENT IS RUN IN A
PARTICULAR COMPUTING
ENVIRONMENT, THE OUTPUT WILL BE
THE SAME, FOR EXAMPLE:
-2 0 1 -3 -1 0 0 1 -2 -2
WHY WOULD WE WANT THE SAME
SEQUENCE EVERY TIME? WE CAN
COMPARE DIFFERENT METHODS WITH
THE SAME SEQUENCE OF RANDOM
VALUES.
IN GENERAL, REPEATABILITY IS A
HALLMARK OF THE SCIENTIFIC
METHOD.
SOFTWARE DEVELOPMENT LIFECYCLE
STAGE IV: PROGRAM MAINTENANCE
MODIFICATIONS TO A PROGRAM
THAT HAS BEEN DEPLOYED
MODIFICATIONS DUE TO:
ERRORS FOUND
ENHANCEMENTS MADE
CHANGE IN COMPUTINGENVIRONMENT
THERE IS NO “NATURAL
DEGRADATION” OF SOFTWARE.
EXERCISE: WRITE THE CODE TO
DETERMINE HOW LONG IT TAKES
TO GENERATE THE RANDOM
INTEGER 11111 IF THE INITIAL
SEED IS 100.
HINT: while (…);
RECALL THE TIMER SKELETON: