SoftwareDevelopment

In its "most fundamental form", software development is the programming of a computer. Nicholas Werth, the designer of the Pascal programming language, said that a program consisted of its algorithm (the detailed method of solution) and its data structures (the organization of its data). "Structured programming" was the disciplined strategy for efficiently developing software in the 70's and 80's. In the 90's the strategies of structured programming were generalized into a higher level strategy called object-oriented software development (OOSD), often called "object-oriented programming", or object technology (OT). During all this time, the efficient development of quality software has been the first skill that must be mastered by computer professionals. In the early days of computing (as well as in current university computer science curricula), programming was essentially an individual undertaking. However, as software became more sophisticated, software development evolved into a group enterprise. Now "computer programming" has given way to "Software Engineering" which incorporates the design, production, and maintenance of software as if it were an engineering project involving a team. This basic view was the foundation of OT, which has yet to mature, but is definitely the "wave of the present AND the future". Regardless of the strategy, the essential feature of software development, like all problem solving, is "divide and conqueor", i.e. subdivide overwhelming problems into smaller ones until the small problems can be solved.

Because this is an introductory course we will not delve to deeply into the details of software development strategy so our limited goals of this Learning Module VI are to help the student:

TPQ 1: Rewrite the preceding objectives in terms of personal accomplishments to be attained after finishing the study of this learning module.

__________(1) the "problem" with the goal of understanding it. Specify the requirements (often called "requirements analysis"), i.e. determine what input is required and what output is desired. (Common sense says: know what you start with and know what results you want.)
__________(2) the solution, i.e. the connection between the inputs and the outputs.

search for known solutions

search for shortcuts (solutions to similar problems, solutions parts of the problem, patterns for solutions, tools like theorems, rules, guidelines, etc.)

divide and conquer, i.e. break the problem into smaller, manageable subtasks that give intermediate results that lead to the final solution.

brainstorm; consider all alternatives; don't become tranfixed with a single approach.

test and debug solution and constituent subtasks.

__________(3) the __________(2), (planned in the preceding step) in the appropriate environment, e.g. in digital electornics, create the circuit; in architecture, construct the building; in software, write the source code, etc. Test and debug.
__________(4) the __________(3), (created in the preceding step), i.e.

fix faults encountered during use
modify features to imporve performance
update facilities to account for changes in the environment.

TPQ 2: Compare (a) general problem solving (e.g. math, physics, etc.) and (b) technical writing to the generalization of Polya's heuristics, given above.

This section in D&L illustrates how the recipe for Hollandaise sauce expemlifies the "implementation" of an algorithm and how the receipe can be written in pseudocode.

This section in D&L shows how our daily activities are examples of implementing algorithms, i.e. carrying out a sequence of instructions.

INPUT-PROCESS-OUTPUT ALGORITHM
in Flowchart form

The programming cycle is, conceptually, separated into a language independent phase (analysis and design) and a language dependent phase (implementation and testing). This separation is irrelevant to the Documentation phase, but also applies the the maintenance phase, if significant modifications are made to the software.

{NOT IN D&L!} In modern structured and OO programming, logic "control structures" are used to define the logic of an algorithm and govern logic flow of program execution. ( Note that all of the following applies to the development of OO operations/methods that define the behavior of classes, i.e. structured algorithm development is part of OOSD.) In fact, it has been proved that any programmable algorithm can be coded using only three different control structures, sequence, selection, and repetition; actually all one needs is the if-then-else for selection and the while loop for repetition; these are the only ones that should be used by COSC101 students.

Sequence: the default order of program execution, one instruction after another.
Selection: this control structure allows the program to choose one of two or more alternative sets of instructions (subtasks). It involves evaluating a "selector", and, depending on its value, deciding which (if any) set of instructions to execute before passing control to the instruction following the selection.

The most fundamental form is the if-then-else construct (also called "if-then-else" or just "if-else") which facilitates selection of one of two, mutually exclusive sets (blocks) of instructions. It is the "selection" constructor from which all other selection constructs can be created. An example of an if-then-else is:

IF-THEN-ELSE CONTROL STRUCTURE PSEUDOCODE
if (Grade >= 60) then Print "Pass" else Print "Fail" endif

The case statement provides for more than two selection categories; however, this can be simulated using "nested" if-then-else control structures, i.e. if-then-else within other if-then-else structures.

Repetition: the repetition of a block of instructions may be accomplished two ways:

iteration (or looping), the most common form of repetition in data processing languages, is the cycling through a block of instruction over and over until a condition arises that halts the looping. There are two fundamentally distinct types of loops:

definite loops have a predefined number of repetitions e.g. for Index := 0 to 9 print (Index); (* A Pascal "for loop" *) repeat 4 [forward 50 right 90] ; A Logo "repeat loop"
indefinite loops repeat themselves while a looping condition is true or until an "exit condition" occurs; these loops are indefinite because, unlike definite loops, it is NOT known, at the beginning of these loops how many repetitions will occur, i.e. something has to happen within the loop body, to cause the repetitions to end. It is the "while" constructor from which all other repetition constructs can be created. An example of a pseudo code segment using a "while loop":

WHILE CONTROL STRUCTURE PSEUDOCODE
Set sum to 0 Set digit to 1 while (digit <= 9) Set sum to sum + digit Set digit to digit +1 endWhile

SAQ: (a) What does the preceeding while loop do? (b) Rewrite the preceding algorithm using "Tony's shorthand" with "<-".

Recursion, the preferred method of repetition in artificial intelligence languages like PROLOG, LISP or Logo, involves a subprogram "calling" itself (i.e. doing its instructions) over and over until a condition arises that halts the repetition.

A powerful strategy for solving algorithmic problems is given in the appendix Problem Solving: Developing Algorithms which introduces structured algorithm charts (SACs) which are the most powerful, efficient "tool" for helping developers design elegant algorithms, of which I know.

Notes:

the discussion in section C, above, simply means that algorithm instructions are executed sequentially UNLESS this is modified by selection or repetition control structures.
Although there are several kinds of the selection and repetition control structures, it has been proved that any programmable task can be performed using only the if-then-else for selection and while for repetition. This sounds deceptfully simple, until one realizes that selections an repetitions can be nested, i.e. occur within each other and within them selves. Anyway, to represent structured algorighms, one must have, at a minimum, an if-then-else construct and a while loop; this applies to pseudocode or flowcharts, both of which can represent algorithm logic.
Appendix Problem Solving: Developing Algorithms proved and illustrated that there are only two ways to organize control structures, in sequence or nested:

Sequential control structures are independent, i.e. occur one after another.
Nested control structures mean that one control structure "contains" other control structures within them. Consequently the nested control structures are dependent on those control structures that contain them.

The "structured programming" paradigm, covered in section 2, above, was based on using structured control constructs() (selection and repetition) for controlling program flow and abstraction() facilities (data types and modular constructs like procedures and functions) for modularizing software. These were provided in sturctured programming languages like Pascal, C, etc. Next, the modularization/abstraction trend was extended to "object-based programming" with the introduction of the class construct which allowed modelling of "objects". The "class" formalized the encapsulation of state (data declarations called "attributes") and behavior (operation definitions called "methods") into one module, the class; modular programming languages included Modula 2, Ada, etc. Finally the transition to "object-oriented software development" (OOSD) was completed with the addition of inheritance and polymorphism which minimized redundancies and maximized the human point of view; object-oriented programming languages included Modula 3, Ada 95, C++, Java, etc. Therefore, we can concisely specify the difference between strutured programming and OOSD by saying OOSD includes all of the the concepts of structued algorithms plus the following.