Unit 1: Introduction to programming —

in-depth notes
Computer software and their classification
Overview and purpose

 System software: Provides the core environment for running and managing hardware
and applications.

Based on the surrounding page content, System Software refers to the essential programs that
help a computer run and manage its hardware. It acts as the foundation upon which all other
software operates.

🔑 Key Points from the Page

 Definition: System software manages hardware resources and provides a platform for
application software to function.
 Examples:
o Operating Systems (Windows, Linux, macOS) → They control the overall
functioning of the computer.
o Device Drivers → Specialized programs that allow hardware (like printers,
keyboards, or graphics cards) to communicate with the operating system.
 Role:
o Ensures smooth interaction between hardware and software.
o Provides core services like memory management, file handling, and process
scheduling.
o Without system software, application software (like MS Word or Photoshop)
cannot run.

🎓 Simplified Analogy (from the page’s teaching style)

Think of a computer as a car:

 System Software = Engine → It makes the car run and controls how all parts work
together.
 Application Software = Car itself → What you actually drive and use.
 Utility Software = Mechanic tools → Helps maintain and fix issues.
 Programming Software = Garage → Where new cars (programs) are built.

👉 In short, System Software is the invisible backbone of computing, ensuring that hardware
and applications can work together seamlessly.
  Application software: Solves end-user tasks and domain needs.
 Utility software: Maintains, monitors, and optimizes systems.
 Programming software: Enables creating, building, and analyzing software.

System software

 Definition: Software that interfaces directly with hardware and coordinates system
resources.
 Components:
o Operating systems: Windows, Linux, macOS — process scheduling, memory
management, file systems.
o Device drivers: Translate OS requests into hardware actions (e.g., printer, GPU).
o Firmware: Low-level, persistent control software embedded in hardware.
 Key ideas: Abstraction layers, resource management, concurrency, security.
 Common pitfalls: Misconfigured drivers, incompatible kernels, permission issues.

Application software

 Definition: Programs designed for users’ tasks.

 Types:
o Productivity: Word processors, spreadsheets.
o Multimedia: Editors for images/audio/video.
o Browsers and communication: Chrome, WhatsApp.
o Specialized: CAD, GIS, scientific tools.
 Distribution models: Standalone, client-server, web apps, mobile apps.
 Quality concerns: Usability, reliability, performance, accessibility, updates.

Utility software

 Definition: Focused tools for maintenance and diagnostics.

 Examples: Anti-virus, backup tools, disk defragmenters, compression.
 Use cases: Performance tuning, security scanning, recovery.
 Caveats: False positives in security tools, over-optimization, privacy settings.

Programming software

 Definition: Toolchain for developers.

 Components:
o Editors/IDEs: VS Code, Code::Blocks — syntax highlighting, refactor tools.
o Compilers/interpreters: Translate source to executable behavior.
o Debuggers/profilers: Inspect runtime state, measure performance.
o Version control: Git for change tracking and collaboration.
 Workflow: Edit → build → run → test → debug → commit → release.

Program, programming, and programming languages

Program

 Definition: A finite, ordered set of instructions that transforms inputs into outputs.
 Properties: Correctness, efficiency, readability, maintainability.
 Artifacts: Source code, configuration, assets, documentation.
 Example: A C program that reads numbers and prints their average.

Programming

 Definition: The process of analyzing problems, designing solutions, implementing code,

and validating behavior.
 Core activities:
o Problem analysis: Inputs, outputs, constraints, edge cases.
o Design: Algorithms, data structures, modular decomposition, interfaces.
o Implementation: Writing code that follows language rules and style guides.
o Verification: Testing, debugging, code reviews.
 Good practices: Clear naming, small cohesive functions, comments only for
non-obvious logic, consistent formatting, tests.

Programming languages

 Purpose: Formal notations to express computations that machines can execute.

 Levels:
o Low-level: Machine code (binary), assembly (mnemonics) — fast,
hardware-close, hard to maintain.
o High-level: C, Java, Python — portable, readable, feature-rich.
o Very high-level/domain-specific: SQL, MATLAB, R — specialized
abstractions.
 Paradigms:
o Procedural: C, Pascal — functions, control flow, mutable state.
o Object-oriented: Java, C++ — classes, encapsulation, inheritance.
o Functional: Haskell, Lisp — pure functions, immutability, higher-order
functions.
o Scripting: Python, JavaScript — interpreted, rapid development.
 Trade-offs: Performance vs productivity, control vs safety, portability vs platform
features.

Timeline of programming languages

Early era (1940s–1960s)

 Machine language: Direct binary instructions — fastest, error-prone.

 Assembly language: Symbolic mnemonics and labels — slightly higher abstraction.
 FORTRAN (1957): Scientific computing; arrays, loops, compiled performance.
 COBOL (1959): Business data processing; verbose, record handling.
Structured programming (1970s)

 C (1972): Systems programming; pointers, manual memory, low-level access,

portability.
 Pascal (1970): Education; strong typing, structured control, clarity focus.

Object orientation and systems growth (1980s–1990s)

 C++ (1985): C + OOP; classes, templates; powerful but complex.

 Java (1995): “Write once, run anywhere”; VM-based, garbage-collected, large standard
library.
 Scripting rises: Perl, PHP for web and text processing.

Modern ecosystems (2000s–present)

 Python: Readability, batteries-included, data science dominance.

 JavaScript: Web runtime ubiquity; [Link] enables server-side JS.
 Go: Simplicity, concurrency with goroutines, fast builds.
 Rust: Memory safety without garbage collection; ownership/borrow checker.
 Trends: Safety, concurrency, developer experience, cross-platform delivery.

📜 Timeline of Programming Languages — Explained from the Page Context

From the surrounding page content in Unit 1: Introduction to Programming, the Timeline of
Programming Languages shows how programming evolved over decades, reflecting changes in
technology, user needs, and computing paradigms.

🕰️Early Era (1940s–1960s)

 Machine Language → Direct binary instructions (0s and 1s). Fast but error-prone and
very hard for humans to use.
 Assembly Language → Symbolic mnemonics (like ADD, MOV) instead of raw binary.
Slightly easier but still hardware-specific.
 FORTRAN (1957) → First high-level language for scientific computing. Introduced
arrays, loops, and compiled performance.
 COBOL (1959) → Designed for business data processing. Verbose, focused on records
and transactions.

📐 Structured Programming (1970s)

 C (1972) → Powerful systems programming language. Introduced pointers, manual

memory management, and portability across platforms.
 Pascal (1970) → Educational language emphasizing clarity, strong typing, and structured
control flow.

🧩 Object Orientation & Systems Growth (1980s–1990s)

  C++ (1985) → Extended C with object-oriented features (classes, templates). Powerful
but complex.
 Java (1995) → “Write once, run anywhere.” Based on a virtual machine, garbage
collection, and a large standard library.
 Scripting Languages Rise → Perl, PHP for web development and text processing.

🌐 Modern Ecosystems (2000s–Present)

 Python → Readability-focused, “batteries included,” dominant in data science and AI.

 JavaScript → Ubiquitous in web browsers; [Link] expanded it to server-side
programming.
 Go → Simple, fast builds, concurrency with goroutines.
 Rust → Memory safety without garbage collection, ownership/borrow checker.

🔑 Trends Highlighted in the Page

 Shift from low-level control → to high-level productivity.

 Emphasis on safety, concurrency, developer experience, and cross-platform delivery.
 Each generation of languages solved limitations of the previous ones (e.g., readability,
portability, safety).

Problem analysis, algorithm, and flowchart

Problem analysis

 Inputs: What data is given? Types, ranges, format.

 Outputs: What results are required? Precision, units, format.
 Constraints: Time, space, resources, accuracy, platform limitations.
 Edge cases: Empty data, extremes, invalid inputs, duplicates.
 Example: “Find the largest of three integers” → inputs: three ints; output: max;
constraints: single pass, handle equal values.

Algorithm

 Definition: A finite, unambiguous, stepwise procedure that solves a problem.

 Characteristics: Correctness, termination, determinism (or defined randomness),
efficiency.
 Design tools: Pseudocode, invariants, proof of correctness, complexity analysis.
 Example (max of three):
o Steps: Compare a and b → keep larger; compare with c → result is max.
o Complexity: Time O(1) (constant steps), space O(1).

Flowchart
  Purpose: Visual representation of algorithmic control flow.
 Symbols:
o Start/End: Oval.
o Process: Rectangle.
o Decision: Diamond.
o Input/Output: Parallelogram.
o Connector/arrow: Direction of flow.
 Guidelines: Clear labels, consistent flow top-to-bottom, one entry/exit per block where
possible, handle decisions with explicit branches.
 Example outline: Start → Input a,b,c → Decision (a ≥ b?) → Process (max = a or b) →
Decision (max ≥ c?) → Process (max = max or c) → Output max → End.

🧩 Problem Analysis, Algorithm, and Flowchart — Explained from the Page

Context

From the surrounding page content in Unit 1: Introduction to Programming, these three
concepts are introduced as the foundation of program design. They describe how programmers
move from understanding a problem → to designing a solution → to visually representing it
before writing code.

🔍 Problem Analysis

 Definition: Breaking down the problem into inputs, outputs, constraints, and edge cases.
 Steps (from the page):
o Inputs → What data is given? (e.g., three integers).
o Outputs → What result is required? (e.g., the largest integer).
o Constraints → Time, space, accuracy, or platform limitations.
o Edge Cases → Empty data, extreme values, invalid inputs, duplicates.
 Example: “Find the largest of three integers.”
o Inputs: three numbers
o Output: maximum number
o Constraints: single pass, handle equal values

⚙️Algorithm

 Definition: A finite, step-by-step procedure to solve a problem.

 Characteristics: Correctness, termination, determinism, efficiency.
 Design Tools: Pseudocode, invariants, proof of correctness, complexity analysis.
 Example (max of three):
1. Compare a and b → keep larger.
2. Compare with c → result is maximum.
 Complexity: Time = O(1), Space = O(1).

📊 Flowchart

 Definition: A visual representation of the algorithm’s control flow.

  Symbols (from the page):
o Oval → Start/End
o Rectangle → Process
o Diamond → Decision
o Parallelogram → Input/Output
o Arrow → Direction of flow
 Guidelines: Clear labels, consistent top-to-bottom flow, one entry/exit per block.
 Example Outline:
o Start → Input a, b, c → Decision (a ≥ b?) → Process (max = a or b) →
Decision (max ≥ c?) → Process (max = max or c) → Output max → End

🎓 Simplified Analogy (teaching style from the page)

 Problem Analysis = Understanding the question (What’s being asked?).

 Algorithm = Writing the solution steps (How to solve it?).
 Flowchart = Drawing the map (Visualizing the solution path).

Program execution, compilation, debugging, and testing

Program execution

 Definition: Running compiled or interpreted code on a runtime environment (OS + CPU

+ libraries).
 Mechanics: Load code → allocate memory → initialize state → process input →
produce output.
 Runtime errors: Division by zero, null/pointer dereference, out-of-bounds access,
resource exhaustion.

Compilation

 Purpose: Translate high-level source code into machine code (object files).
 Phases:
o Preprocessing: Macros, header inclusion, conditional compilation.
o Lexing/parsing: Convert text into tokens/AST; syntax validation.
o Semantic analysis: Type checking, name resolution.
o Optimization: Improve performance without changing behavior.
o Code generation: Emit machine code.
 Outputs: Object files (.o), diagnostics (errors/warnings).
 Common issues: Missing headers, type mismatches, unresolved symbols, macro side
effects.

Debugging
  Goal: Identify and fix defects (syntax, runtime, logic).
 Tools: Debuggers (breakpoints, stepping, watch variables), logs, assertions, sanitizers.
 Strategies:
o Reproduce reliably: Minimal input causing the issue.
o Isolate: Narrow to the smallest failing unit.
o Inspect state: Variable values, memory, call stack.
o Fix and verify: Patch, rerun tests, watch for regressions.
 Pitfalls: Chasing symptoms, overusing prints, ignoring undefined behavior.

Testing

 Levels:
o Unit testing: Individual functions/modules.
o Integration testing: Interactions between components.
o System/acceptance testing: End-to-end against requirements.
 Techniques: Black-box (spec-driven), white-box (structure-driven), boundary testing,
property-based tests.
 Automation: Test frameworks, continuous integration, coverage measurement.
 Quality criteria: Correctness, performance, robustness, security, usability.

Language processors: interpreters, compilers, linkers,

loaders
Interpreters

 Function: Execute code directly, translating line-by-line or statement-by-statement.

 Pros: Faster iteration, easier debugging, portable bytecode or AST evaluation.
 Cons: Typically slower at runtime, runtime errors may occur later in execution.
 Examples: Python CPython, JavaScript engines (V8), shell interpreters.

Compilers

 Function: Translate entire source into machine code or bytecode ahead of execution.
 Pros: Faster runtime, deeper optimizations, static analysis for errors.
 Cons: Longer build cycles, platform-specific binaries, complex toolchains.
 Examples: GCC/Clang (C/C++), Rustc, javac (to bytecode).

Linkers

 Function: Combine object files and libraries, resolve symbol references, produce
executables or libraries.
 Tasks: Address relocation, symbol resolution, static vs dynamic linking decisions, import
tables.
 Issues: “Undefined reference” errors, ABI mismatches, duplicate symbols.
Loaders

 Function: OS component that loads executables into memory, maps segments, resolves
dynamic libraries, sets up runtime.
 Tasks: Memory mapping (text/data/bss), relocation, initializing program entry (main),
passing arguments/environment.
 Errors: Missing shared libraries, permission denials, incompatible architectures.

Putting it together in C (sequential, conditional, iterative

control)
Sequential control

 Definition: Statements execute in written order.

 Use: Initialization, straightforward calculations, I/O.
 Example: Read inputs → compute sum → print result.

Conditional control

 Definition: Branch execution based on truth of conditions.

 Tools: if/else, else-if chains, switch/case, conditional operator.
 Example: Validate input range; choose different formula based on type.

Iterative control

 Definition: Repeat a block until a condition changes.

 Tools: for, while, do-while loops; break/continue for fine control.
 Example: Accumulate values, search arrays, process streams.
 Pitfalls: Infinite loops, off-by-one errors, failing to update loop variables.

Practical examples and common pitfalls

Example: Even/odd checker (C)

 Focus: Conditional and I/O.

 Key points: Use modulus operator, handle invalid input gracefully.

c
#include <stdio.h>

int main(void) {
int n;
printf("Enter an integer: ");
if (scanf("%d", &n) != 1) {
 printf("Invalid input.\n");
return 1;
}
if (n % 2 == 0) {
printf("Even\n");
} else {
printf("Odd\n");
}
return 0;
}

Example: Sum of first N numbers (C)

 Focus: Iteration and accumulation.

c
#include <stdio.h>

int main(void) {
int n;
long long sum = 0;
printf("Enter N: ")
if (scanf("%d", &n) != 1 || n < 0) {
printf("Please enter a non-negative integer.\n");
return 1;
}
for (int i = 1; i <= n; i++) {
sum += i;
}
printf("Sum = %lld\n", sum);
return 0;
}

Pitfalls to watch

 Undefined behavior: Using uninitialized variables, out-of-bounds array access, integer

division by zero.
 Input handling: Not checking scanf return values, buffer overflows with gets (avoid; use
fgets).
 Memory: Forgetting to free dynamically allocated memory; double free; dangling
pointers.
 Logic errors: Off-by-one in loops; incorrect condition ordering in if/else chains.