CSCI 241 Labs: PreLab 4

CSCI 241 Labs: PreLab 4
Think Before You Leap

Introduction

Way too often in CSCI 241 students think that working on a project or lab means typing things at the computer. In truth, professional programmers only spend about 25% of their time coding. Most of the rest of the time is spent designing and testing their systems.

The types of design decisions programmers make fall into two basic categories:

Deciding what classes and methods should go into the system.
Most professional software is developed by software engineers who work in teams. Team leaders assign responsibility for implementing various classes to individual programmers on the team. The programmer must be aware of exactly what their class must do, before they can begin implementing it. Obviously, these top-level design decisions must be made early and are critical to the success of the system. Fortunately for you, in CSCI 241 your instructors will usually give you descriptions of the classes and/or methods you need to write. If they don't, the project should still be small enough that the choices will be obvious.
In chapter 6, we will learn how to write code with separate methods. In chapter 9, we will learn how to write our own separate classes.
Deciding on the logic inside of each method.
In chapters 1-2 of the text there was very simple logic in each main()method. The CPU started running at the first line and executed the code in a line by line fashion until it reached the end of the method.
Chapter 3 discusses how a computer program makes decisions. This can greatly complicate your code. Thinking clearly about (and writing down) what the code should look like before you jump in and start typing is critical.

Pseudocode

A standard technique for documenting the design of a method is pseudocode. (Pseudocode is defined in your text in Chapter 2 on page 34.) The purpose of pseudocode is to document your thoughts about the logic needed for a task before you ever sit down at the computer. It documents the algorithm without worrying about the syntax of a particular language.

Here is the Merriam-Webster Dictionary definition of an algorithm:

a procedure for solving a mathematical problem (as of finding the greatest common divisor) in a finite number of steps that frequently involves repetition of an operation; broadly : a step-by-step procedure for solving a problem or accomplishing some end especially by a computer.

Aside: In real world software development, the design of the system is considered an important piece of documentation even after the system is completed. When a programmer has to make a change to a method, say to fix a Y2K bug or make the system work under another operating system, she usually starts by reading through the design documentation for the method.

There are just a few rules for writing pseudocode:

Write down all the important steps of the algorithm without paying attention to the rules of the language.
Don't worry about where the semicolons go or whether you need squiggly braces.
Don't worry about the name of a particular method you want to call, instead refer to it by what it does. For example, System.out.println(x); can simply be referred to in the pseudocode as print x
Include things that are needed for the algorithm to make sense to a human reader, such as you or your instructor. This includes consistent indentation to show when you are inside a class, method or block of code. (It also includes showing how parameters and variables are used; these will be defined in chapter 5).
Include anything that adds to the clarity of the logic.
Exclude anything that seems like a "yucky" language detail (such as semi-colons).

Examples

Consider the problem that instructors face every semester: assigning letter grades to students based on their performance on a series of exams. In our case, let's assume there are three exams which all count equally. A program to process the data would require at least two sections: one to calculate the average and one to assign a grade based on that average. Here is pseudocode for each:

calculateAverage section

   average = (exam1 + exam2 + exam3) / 3

   print average

end calculateAverage section

Note when looking at the above pseudocode that many of the details are missing. It does not include variable declarations, because the data types are language-specific. It does not indicate how the numbers for each exam score are collected by the program. They could come from standard input, a GUI input dialog box or read from a file. It is left for the reader to figure out that the average should be a double. The division is by three, where you should know that here we would want 3.0 when writing the method in Java. When the calculated average is printed, it will probably include text explaining the meaning of the number. Do you see how to translate the above pseudocode into Java code?

Here is the other section's pseudocode:

assignGrade section

   if average >= 90

      grade = 'A'

   else if average >= 80

      grade = 'B'

   else if average >= 70

      grade = 'C'

   else if average >= 60

      grade = 'D'

   else

      grade = 'F'

   print grade

end assignGrade section

Pay particular attention to the indentation in this example. Note that the print statement is at the same level of indentation as the if..else. This means the print is not inside the if block.

What will be returned if the score entered is 50? 87? 90? Do you see how to translate the above pseudocode into Java code?

A Range of Correct Solutions

It is important to realize that in many problems the algorithm is not unique. In the above example, we could written this alternatively:

assignGrade section

   if average < 60

      print 'F'

   else if average < 70

      print 'D'

   else if average < 80

      print 'C'

   else if average < 90

      print 'B'

   else

      print 'A'

end assignGrade section

We have:

Changed the order in which the grade ranges are checked.
Removed local variable grade.
Inserted additional print statements.

The algorithm is still completely correct.

When we are checking for equality against a range of values, we can also frequently choose between using an if or a switch statement.

There are many correct algorithms for some problems. The differences between them are often trivial and irrelevant. Sometimes the biggest difference between them is in how fast they run. We will look at the efficiency of algorithms later this semester and give it a more complete treatment in CSCI 242 and CSCI 340.

In this week's lab you will be asked to create pseudocode for algorithms to solve particular problems and then implement the algorithms in Java.