The Pseudocode Programming Process SCMP 391.00 Special Topic: Software Development Spring 2017 James Skon

Steps for Building Classes and Routines Class construction is an iterative process.

Steps in Creating a Class Create a general design for the class Construct each routine within the class Review and test the class as a whole

Steps in Creating a Class Create a general design for the class Define the class's specific responsibilities Define the classes hidden state (secrets) Define what abstraction the class interface will capture Will the class be derived from another class and with other classes be allowed to derive from it? Identify the class's key public methods What are the data members?

Steps in Creating a Class Create a general design for the class Construct each routine within the class Build the routines! Respond to issues by backtracking Review and test the class as a whole Class should be tested by itself, and then in context.

Steps in Building a Routine

Pseudocode Informal, English-like notation for describing how an algorithm, a routine, a class, or a program will work. Calculate Pay with Overtime Begin input hours, rate if hours ≤ 40 then pay = hours * rate else pay = 40 * rate + (hours – 40) * rate * 1.5 print pay End

Pseudocode Use English-like statements that precisely describe specific operations. Avoid syntactic elements from the target programming language. Write pseudocode at the level of intent.

Pseudocode increment resource number by 1 BAD! increment resource number by 1 allocate a dlg struct using malloc if malloc() returns NULL then return 1 invoke OSrsrc_init to initialize a resource for the operating system *hRsrcPtr = resource number return 0 Keep track of current number of resources in use If another resource is available Allocate a dialog box structure If a dialog box structure could be allocated Note that one more resource is in use Initialize the resource Store the resource number at the location provided by the caller Endif Return true if a new resource was created; else return false Good!

Why Pseudocode? Pseudocode makes reviews easier. Pseudocode supports the idea of iterative refinement. Pseudocode makes changes easier. Pseudocode minimizes commenting effort. Pseudocode is easier to maintain than other forms of design documentation.

Constructing Routines Design the routine. Code the routine. Check the code. Clean up loose ends. Repeat as needed.

Design the routine Create a specification: ReportErrorMessage() takes an error code as an input argument and outputs an error message corresponding to the code. It's responsible for handling invalid codes. If the program is operating interactively, ReportErrorMessage() displays the message to the user. If it's operating in command-line mode, ReportErrorMessage() logs the message to a message file. After outputting the message, ReportErrorMessage() returns a status value, indicating whether it succeeded or failed.

Design the routine Check the prerequisites Is the job well defined? Define the problem the routine will solve he information the routine will hide Inputs to the routine Outputs from the routine Preconditions guaranteed to be true before the routine is called Postconditions guarantees will be true after routine Name the routine

Design the routine Decide how to test the routine Research functionality available in the standard libraries Think about error handling Think about efficiency Research the algorithms and data types Write the pseudocode

Write the pseudocode Start with the general and work toward something more specific. Write a concise header statement ReportErrorMessage This routine outputs an error message based on an error code supplied by the calling routine. The way it outputs the message depends on the current processing state, which it retrieves on its own. It returns a value indicating success or failure.

Write the pseudocode ReportErrorMessage This routine outputs an error message based on an error code supplied by the calling routine. The way it outputs the message depends on the current processing state, which it retrieves on its own. It returns a value indicating success or failure. set the default status to "fail" look up the message based on the error code if the error code is valid if doing interactive processing, display the error message interactively and declare success if doing command line processing, log the error message to the command line and declare success if the error code isn't valid, notify the user that an internal error has been detected return status information

Write the pseudocode Think about the data – What are the data elements, how appropriate are they? Check the pseudocode Try a few ideas in pseudocode, and keep the best (iterate)

Code the Routine

Code the Routine - declaration /* This routine outputs an error message based on an error code supplied by the calling routine. The way it outputs the message depends on the current processing state, which it retrieves on its own. It returns a value indicating success or failure. */ <-- 1 Status ReportErrorMessage( ErrorCode errorToReport ) set the default status to "fail" look up the message based on the error code if the error code is valid if doing interactive processing, display the error message interactively and declare success if doing command line processing, log the error message to the command line and declare success if the error code isn't valid, notify the user that an internal error has been detected return status information Header comment interface statement

Code the Routine – first and last statement /* This routine outputs an error message based on an error code supplied by the calling routine. The way it outputs the message depends on the current processing state, which it retrieves on its own. It returns a value indicating success or failure. */ Status ReportErrorMessage( ErrorCode errorToReport ) { // set the default status to "fail" // look up the message based on the error code // if the error code is valid // if doing interactive processing, display the error message // interactively and declare success // if doing command line processing, log the error message to the // command line and declare success // if the error code isn't valid, notify the user that an // internal error has been detected // return status information } pseudocode statements from here down have been turned into C++ comments

Code the Routine – Fill in the code Programming Process /* This routine outputs an error message based on an error code supplied by the calling routine. The way it outputs the message depends on the current processing state, which it retrieves on its own. It returns a value indicating success or failure. */ Status ReportErrorMessage( ErrorCode errorToReport ) { // set the default status to "fail" Status errorMessageStatus = Status_Failure; // look up the message based on the error code Message errorMessage = LookupErrorMessage( errorToReport ); // if the error code is valid if ( errorMessage.ValidCode() ) { <-- 1 // determine the processing method ProcessingMethod errorProcessingMethod = CurrentProcessingMethod(); // if doing interactive processing, display the error message // interactively and declare success if ( errorProcessingMethod == ProcessingMethod_Interactive ) { DisplayInteractiveMessage( errorMessage.Text() ); errorMessageStatus = Status_Success; } The code for each comment has been filled in

Code the Routine – Fill in the code // if doing command line processing, log the error message to the // command line and declare success else if ( errorProcessingMethod == ProcessingMethod_CommandLine ) { CommandLine messageLog; if ( messageLog.Status() == CommandLineStatus_Ok ) { messageLog.AddToMessageQueue( errorMessage.Text() ); messageLog.FlushMessageQueue(); errorMessageStatus = Status_Success; } else { // can't do anything because the routine is already error processing // if the error code isn't valid, notify the user that an // internal error has been detected DisplayInteractiveMessage( "Internal Error: Invalid error code in ReportErrorMessage()" ); // return status information return errorMessageStatus; good candidate for being further decomposed

Code the Routine Check whether code should be further factored In some cases, you'll see an explosion of code below one of the initial lines of pseudocode. Factor the code below the comment into a new routine.

Check the Code After designing and implementing the routine, the third big step in constructing it is checking to be sure that what you've constructed is correct. Any errors you miss at this stage won't be found until later testing.

Compile the routine Set the compiler's warning level to the pickiest level possible. Use validators. (lint) Eliminate the causes of all error messages and warnings.

Test the code Test the code using the test cases you planned or created while you were developing the routine.

Clean Up Leftovers Check the routine's interface. Check for general design quality. Check the routine's variables. Check the routine's statements and logic. Check the routine's layout. Check the routine's documentation. Remove redundant comments.

Code the Routine

Code the Routine - Example /* This routine outputs an error message based on an error code supplied by the calling routine. The way it outputs the message depends on the current processing state, which it retrieves on its own. It returns a value indicating success or failure. */ Status ReportErrorMessage( ErrorCode errorToReport ) set the default status to "fail" look up the message based on the error code if the error code is valid if doing interactive processing, display the error message interactively and declare success if doing command line processing, log the error message to the command line and declare success if the error code isn't valid, notify the user that an internal error has been detected return status information Header comment turned into a c++ comment Interface statement

Code the Routine - Example Status ReportErrorMessage( ErrorCode errorToReport ) { // set the default status to "fail" Status errorMessageStatus = Status_Failure; // look up the message based on the error code Message errorMessage = LookupErrorMessage( errorToReport ); // if the error code is valid // if doing interactive processing, display the error message // interactively and declare success // if doing command line processing, log the error message to the // command line and declare success // if the error code isn't not valid, notify the user that an // internal error has been dtected // return status information Code filled in New variable for errorMessage

Check the Code After designing and implementing the routine, the third big step in constructing it is checking to be sure that what you've constructed is correct. Mentally check the routine for errors Understand “why” the routine works Compile the routine Let the compiler look for errors Step through the code with a debugger Test the program

CLEAN UP LEFTOVERS Check the routine's interface.. Check for general design quality. Check the routine's variables. Check the routine's statements and logic. Check the routine's layout. Check the routine's documentation. Remove redundant comments.