Decomposition in Programming Concepts

Decomposition

• Decomposition is breaking a problem into smaller, manageable tasks to reduce complexity.
• It involves three key parts:
  • Identifying and describing the problem and its processes.
  • Breaking the problem down into distinct steps.
  • Describing the problem and processes in a structured way.
• Identifying the Problem:
  • Determine the program's goals and functions.
    • Requirements: tasks the software must perform (correct results are key).
    • Specification: detailing the program's operation (flowchart).
      • Example for a calculator: welcome message, value input, operator input, another value input, result display.
• Breaking Down Problems into Steps:
  • Computer programs operate on binary logic (true/false).
  • Program steps need defined true/false conditions to avoid ambiguity.
    • Example if/else statements for decision-making.
    • Code order affects output (examples shown).
• Describing Problems in Structured Steps:
  • Programs execute instructions sequentially (unless otherwise directed).
  • Order matters; different order leads to different results.

Pattern Recognition

• Pattern Recognition is identifying patterns and trends in data or problems to understand relationships.
• This is essential for generalising and automating data.
• Example: Police notice more crime at night, leading to the generalization that criminals prefer darkness.

Pattern Generalisation

• Pattern Generalisation uses observed patterns to create broad rules or formulas.
• It applies patterns to different datasets and problems.
• Example: the sequence 2, 4, 6, 8... shows a pattern where each term increases by 2; generalisation is finding the nth term (2n).

Algorithmic Design

• Algorithmic design creates efficient algorithms to solve problems.
• It involves careful planning and structure for maintainability.
• Computational thinking requires decomposition, abstraction, pattern recognition/generalisation and algorithmic design.

Flowcharts

• Flowcharts visually represent algorithms. Arrows and boxes represent operations.
• Symbols are standard across flowchart programs.

Pseudocode

• Pseudocode is easy-to-understand text; programmers of different languages can understand it.
• It's a way to represent an algorithm and avoid language-specific details.
• It aids in creating code that avoids important elements being missed.
• Includes statements like #comment, INPUT, OUTPUT, FUNCTION/ENDFUNCTION, IF/THEN/ELSE/ENDIF, FOR/ENDFOR, REPEAT/UNTIL.

Handling Data within Programs

• Characters: Single symbols (letters, punctuation). Can be converted to integers (e.g., for Caesar Cipher).
• Strings: Sequences of characters (denoted by "" or ''). Often treated as character arrays.
  • Alphanumeric strings: Contain only letters and numbers.
• Objects: Instances of classes (blueprints).
• Floating Points: Non-integer values. Includes double precision and decimal representations.
• Arrays/Lists: Store multiple data items of the same type.
  • Arrays: Fixed size, often limited to one data type. More efficient for numerical computations.
  • Lists: Dynamic size, can hold different data types. Less efficient, but more flexible.
• Booleans: Represent true/false values.
• Integers: Whole numbers (positive or negative).
• Sets: Cannot contain duplicates, useful for unique values.
• Records: Key-value pairs for structured data. Useful for organizing related data (like book details).
• Date/Time: Complex data type requiring consideration of calendars, time zones, formats, and leap years.

Managing Variables

• Variable Names: Should be descriptive (e.g., username). Standard naming conventions (snake_case, camelCase, PascalCase).
• Global Variables: Declared outside any function, accessible throughout the program. Use sparingly and judiciously.
• Local Variables: Used within a specific function or block. Improved code modularity. Reduces memory usage.