Unit 9: Software Programming and Development

I. Orientation: Programs, Languages, and the Development Idea

Software programming is the disciplined activity of expressing a solution to a problem as a precise sequence of instructions a computer can execute. A program bridges human intention and machine operation: humans think in goals and logic, machines respond only to binary electrical states, and programming languages sit between the two. Every idea in this unit depends on that bridge and on the layered way instructions descend from readable source code to executable machine action.

Defining properties that later sections rely on:

• Instruction-driven: A computer does nothing on its own; it only follows explicit, ordered instructions supplied to it.
• Deterministic execution: Given the same input and the same instructions, a program produces the same result every time.
• Layered translation: High-level source code is converted (compiled or interpreted) into machine code of binary 1s and 0s the CPU understands.
• Fetch-decode-execute: The processor repeatedly fetches an instruction, decodes it, and executes it, one step at a time.
• Stored-program concept: Both instructions and data reside together in memory (the von Neumann model), so programs can be loaded, replaced, and modified.

II. What Is a Computer Program

A definition of the program as the fundamental software artifact and its structural parts.

A. Definition and Nature

A computer program is a finite, ordered set of instructions written in a programming language that directs a computer to perform a specific task.

• Instructions: Individual commands such as "add two numbers", "read a file", or "display text"; the CPU carries out one per cycle.
• Finiteness: A program has a definite beginning and end; it must eventually terminate or loop under defined conditions rather than run meaninglessly.
• Language dependence: Written in a notation with fixed syntax (grammar rules) and semantics (meaning), for example print("Hello") in Python.
• Software vs. hardware: The program is software, the intangible logic; the machine executing it is hardware, the physical circuitry.

B. Components of a Program

• Input: Data supplied to the program, e.g. numbers typed by a user or read from a sensor.
• Processing: The logic and calculations applied, expressed through statements, expressions, and control structures.
• Output: The result produced, such as a printed report or a value stored to disk.
• Data and variables: Named storage locations holding values that change during execution, e.g. total = price * quantity.

C. Categories of Programs

• System software: Programs that run and manage the machine, e.g. operating systems, device drivers, utilities.
• Application software: Programs that serve user tasks, e.g. word processors, browsers, spreadsheets.
• Source vs. executable form: Source code is human-readable text; the executable is the translated binary the machine actually runs.

III. Hardware/Software Interaction

The mechanism by which written instructions become physical machine activity across the system's layers.

A. Purpose and Principle

Software cannot act directly on circuits; it works through a stack of translation layers that convert high-level commands into electrical signals, with the operating system coordinating access to hardware.

• Layered model: Application software → operating system → device drivers → hardware.
• Abstraction: Each layer hides the complexity of the one below, so an application need not know how a disk physically stores bits.

B. Role of the Operating System

• Resource manager: Allocates CPU time, memory, and I/O devices among competing programs.
• Intermediary: A program requests a service (open a file, print a page) through a system call, and the OS performs the hardware operation on its behalf.
• Isolation: Prevents one program from corrupting another's memory, keeping the system stable.

C. The Machine Cycle and Instruction Execution

Hardware executes machine code through the repeating fetch-decode-execute cycle.

1. FETCH   – get next instruction from memory (address in program counter)
2. DECODE  – control unit interprets the instruction
3. EXECUTE – ALU or other unit performs the operation
4. STORE   – write result back to a register or memory

• CPU components: The control unit directs operations; the ALU (arithmetic logic unit) performs calculations and comparisons; registers hold data being worked on.
• Program counter: Holds the address of the next instruction, ensuring correct sequencing.

D. Translation: Compilers and Interpreters

Two contrasting routes convert source code into executable machine action.

1. Compiler: Translates the entire program into machine code once, producing a standalone executable. Faster at run time; errors are caught before running. Example: C, C++.
2. Interpreter: Translates and executes one statement at a time, with no separate executable. Easier to debug and portable; slower during execution. Example: Python (in its standard form).

• Assembler: A special translator that converts low-level assembly language (mnemonics like MOV, ADD) into machine code.

IV. Planning a Computer Program

The design work that precedes coding, defining what to build and how before writing a single line.

A. Purpose and Principle

Good programs are planned before they are typed; planning clarifies the problem, reduces errors, and produces a blueprint the coding stage can follow directly.

• Cost of skipping: Bugs and design flaws found late are far more expensive to fix than those caught during planning.

B. The Program Development Life Cycle

A structured sequence of stages carries a program from idea to maintained product.

• Problem definition: State precisely what the program must accomplish and its constraints.
• Analysis: Identify required inputs, expected outputs, and the processing that links them (the IPO view: Input–Process–Output).
• Design: Work out the logic and structure of the solution before coding.
• Coding: Write the source code in the chosen language, following the design.
• Testing and debugging: Run the program with sample data, locate errors, and correct them.
• Documentation: Record how the program works, for users and future maintainers.
• Maintenance: Update and improve the program over its useful life.

C. Algorithms

An algorithm is a finite, step-by-step, unambiguous procedure for solving a problem, independent of any programming language.

• Properties: Each step is definite (clear), the procedure is finite (ends), and it produces correct output from valid input.
• Example — sum of two numbers:

Step 1: Start
Step 2: Read A, B
Step 3: SUM = A + B
Step 4: Display SUM
Step 5: Stop

D. Design Tools: Flowcharts and Pseudocode

Two common notations express the planned logic before coding.

1. Flowchart: A diagram using standard symbols to show flow of control.
   • Oval: start/stop terminals.
   • Parallelogram: input/output.
   • Rectangle: processing step.
   • Diamond: decision (yes/no branch).
   • Arrows: direction of flow.
2. Pseudocode: Structured English that reads like code but ignores strict syntax, e.g. IF age >= 18 THEN print "Adult". Easier to write and revise than a diagram.

V. How Programs Solve Problems

The logical building blocks and reasoning by which instructions turn a problem into a computed answer.

A. Principle: Decomposition into Logic

A program solves a problem by breaking it into small, ordered decisions and operations that a machine can perform mechanically, combining three fundamental control structures.

• Sequence: Instructions executed one after another in order.
• Selection: Choosing between paths based on a condition (if/else).
• Iteration: Repeating a block while or until a condition holds (loops).

B. Control Structures in Action

• Sequence example: read price, multiply by quantity, print total — each step depends on the previous result.
• Selection example:

if marks >= 40:
    print("Pass")
else:
    print("Fail")

• Iteration example:

total = 0
for i in range(1, 6):
    total = total + i    # sums 1..5, giving 15

C. Problem-Solving Strategy

Programs mirror a general problem-solving method mapped onto computing constructs.

• Understand the problem: Determine known inputs and the desired output.
• Devise a plan (algorithm): Choose the steps and structures needed.
• Divide and conquer: Split a large task into modules or functions, each solving one sub-problem, e.g. separate routines for input validation, calculation, and display.
• Reusability: A well-written function can be called many times, avoiding repeated code.

D. Data, Logic, and Correctness

Solving a problem correctly depends on handling data and verifying results.

• Variables and data types: Values are stored as specific types (integer, float, string, boolean) so operations behave predictably.
• Logical operators: AND, OR, NOT combine conditions to express complex decisions.
• Testing for correctness: Feed known inputs and check that outputs match expected values; test boundary cases such as zero, empty input, or maximum limits.
• Debugging: Locate and remove logic errors (wrong result, correct syntax) and syntax errors (broken grammar) until the program reliably produces the intended solution.