1.

1 Identify Business Requirements

Requirements Analysis

 System Requirements: These are the specifications that define what the system should
do. They include performance metrics, scalability, security features, and compatibility
with existing systems.
 User Requirements: These focus on what the end users need from the system. They
often include usability, accessibility, and specific functionality tailored to user tasks.

Fact Finding Methods

1. Interviews:
o Conduct structured or unstructured discussions with stakeholders to gather
detailed insights about their needs and expectations.
2. Surveys/Questionnaires:
o Distribute forms to a broad audience to collect quantitative and qualitative data on
user preferences and requirements.
3. Observation:
o Observe users interacting with existing systems to identify pain points,
inefficiencies, and potential improvements.
4. Document Review:
o Analyze existing documentation, manuals, and reports to understand current
capabilities and limitations.

Identify Inputs

 Determine the data and information that the system needs to function. Inputs can include
user data entering forms, files uploaded by users, or data retrieved from external systems.

Identify Processes
  Outline the procedures that the system will perform to transform inputs into outputs. This
could involve calculations, data processing, or business logic.

Identify Outputs

 Specify the results produced by the system. Outputs can include reports, notifications,
data exports, or user interfaces displaying processed data.

1.2 Propose Appropriate Solutions

Alternative Solutions to Business Problems

1. Purchasing Off-the-Shelf Software:

o Pros: Quick implementation, lower cost, established vendor support, and frequent
updates.
o Cons: May not fulfill all specific business needs, limited customization options,
and potential licensing issues.
2. Outsourcing:
o Pros: Access to specialized expertise, cost savings, and ability to focus internal
resources on core activities.
o Cons: Less control over the development process, communication challenges, and
dependency on third-party vendors.
3. Developing Software In-House:
o Pros: Tailored solutions that match specific business requirements, greater control
over the development timeline, and better integration with existing systems.
o Cons: Higher initial costs, longer development times, and the need for in-house
technical expertise.

Carry Out Walkthroughs

 User Involvement in Solving Business Problems: Engage users throughout the solution
development process. This can include:
 o Conducting walkthrough sessions where users provide feedback on proposed
solutions.
o Involving users in testing phases to ensure the solution meets their needs and
expectations.

1.3 Design Algorithms in Line with Identified Problem(s)

Outline the Importance of Design in Programming

 Proper design is crucial for:

o Ensuring that the solution is efficient and meets user requirements.
o Reducing development time by identifying potential issues early.
o Enhancing maintainability and scalability of the software.

Identify Program Design Tools

1. Flowcharts:
o Visual representations of processes that illustrate the sequence of steps in an
algorithm, helping to clarify the logic and flow of the program.
2. Algorithms:
o Step-by-step procedures for solving specific problems or performing tasks, which
can be expressed in various forms, including natural language, pseudocode, or
programming code.
3. Pseudocode:
o A high-level description of an algorithm using plain language that resembles
programming syntax. It provides a way to outline the logic without getting
bogged down in specific syntax rules of a programming language.

Explain Algorithms

 Define Algorithm:
o An algorithm is a finite sequence of well-defined instructions designed to perform
a specific task or solve a particular problem.
  Outline the Characteristics of an Algorithm:
o Finiteness: An algorithm must terminate after a finite number of steps.
o Definiteness: Each step must be precisely defined and unambiguous.
o Effectiveness: Each step must be feasible and executable within a reasonable
amount of time.
o Generality: An algorithm should apply to a broad set of problems, not just a
specific instance.

Convert Program Designs into Code

 After designing algorithms and flowcharts, the next step is to translate those designs into
actual code in a specific programming language. This involves:
o Writing code that adheres to the syntax and semantics of the chosen programming
language.
o Testing the code to ensure it functions as intended and meets the initial business
requirements.
o Iterating on the design and code as necessary based on testing feedback and user
input.

2.1 Identify Flowchart Symbols

Match Flowchart Symbols with Their Functions

1. Input:
o Symbol: Parallelogram
o Function: Represents data entry into the system (e.g., user input, reading data
from a file).

2. Processing:
o Symbol: Rectangle
o Function: Indicates a process or operation performed on the data (e.g.,
calculations, data manipulation).
 3. Output:
o Symbol: Parallelogram
o Function: Represents the output of data (e.g., displaying results, writing data to a
file).

4. Decision:
o Symbol: Diamond
o Function: Indicates a branching point where a decision is made (e.g., yes/no
questions, true/false conditions).

5. Display:
o Symbol: Rectangle with a wavy base
o Function: Represents showing information to the user (e.g., print statements).

6. Connection:
o Symbol: Circle
o Function: Used to connect flowlines in complex flowcharts, indicating
continuation from one point to another.

Apply Relevant Flowchart Symbols for the Three Programming Constructs

 Sequence: Represents a series of steps executed in order.

o Flowchart symbols: Input → Processing → Output.

 Selection: Represents a decision-making process where different paths are taken based
on conditions.
o Flowchart symbols: Decision symbol directs to different paths based on yes/no
outcomes.

 Iteration: Represents a loop where steps are repeated until a certain condition is met.
o Flowchart symbols: Connection from the processing step back to itself or a
decision symbol determining whether to repeat.
Draw Flowcharts for Given Problems

 When tasked with drawing a flowchart, follow these steps:

1. Identify the problem and its requirements.
2. Outline the main steps involved.
3. Use the appropriate flowchart symbols to represent each step.
4. Connect the symbols with arrows to indicate the flow of the process.

2.2 Convert Flowchart Logic into Code

Producing Code for Given Flowchart Using a Selected Programming Language (C++)

 To convert flowchart logic into code:

1. Analyze the flowchart: Break down each symbol into corresponding code
statements.
2. Write the code: Use the C++ syntax to translate the logic from the flowchart into
a functioning program.

Example Flowchart Conversion

 Flowchart Logic:
o Start → Input number → If number > 0 → Output "Positive" → End
 C++ Code:

cpp

 #include <iostream>
 using namespace std;


 int main() {
 int number;
 cout << "Enter a number: ";
 cin >> number;

  if (number > 0) {
 cout << "Positive" << endl;
 }


 return 0;
 }


Install Relevant Compiler

 To compile C++ code, ensure you have a C++ compiler installed. Common options
include:
o GCC (GNU Compiler Collection): Install via package managers (e.g., apt,
brew).
o Microsoft Visual C++: Part of Visual Studio, suitable for Windows users.
o Code::Blocks: An IDE with built-in compiler support for C++.

2.3 Produce Pseudocode

Define Pseudocode

 Pseudocode: A simplified, high-level description of an algorithm that uses plain

language and structured formatting. It is not bound by the syntax rules of any
programming language, allowing for easy understanding and translation into actual code.

Differentiate Pseudocode and Algorithm

 Pseudocode:
o Focuses on the logic of the program without specific syntax.
o Easier for humans to read and understand.
o Example:

 
 IF number > 0 THEN
  PRINT "Positive"
 END IF

 Algorithm:

 A step-by-step procedure defined to solve a specific problem.

 Can be expressed in various forms, including pseudocode, flowcharts, or formal
programming languages.
 More formal and structured than pseudocode but may include complex details.

3.1 Define Features of OOP

Polymorphism

 Definition: The ability of different classes to be treated as instances of the same class
through a common interface. Polymorphism allows for methods to do different things
based on the object it is acting upon.
 Types:
o Compile-time Polymorphism (Method Overloading): The ability to define
multiple methods with the same name but different parameters.
o Run-time Polymorphism (Method Overriding): The ability to redefine a method
in a derived class that has the same name and signature as a method in its base
class.

Inheritance

 Definition: A mechanism where a new class (derived class) inherits properties and
behaviors (methods) from an existing class (base class). This promotes code reusability
and establishes a hierarchical relationship between classes.
 Types:
o Single Inheritance: A derived class inherits from one base class.
o Multiple Inheritance: A derived class inherits from multiple base classes (not
supported in all languages).
 o Multilevel Inheritance: A class inherits from another derived class.

Encapsulation

 Definition: The bundling of data (attributes) and methods (functions) that operate on the
data into a single unit, or class. Encapsulation restricts direct access to some components
of an object and can prevent the accidental modification of data.
 Implementation: Typically achieved using access modifiers (public, private, protected)
to control visibility and access to class members.

Abstraction / Data Hiding

 Definition: The concept of hiding the complex implementation details of a system and
exposing only the necessary parts to the user. This simplifies interaction with objects and
reduces complexity.
 Implementation: Achieved through abstract classes and interfaces that define abstract
methods without providing a complete implementation.

3.2 Identify Software Architecture

 Definition: Software architecture refers to the high-level structure of a software system,

defining its components, their relationships, and how they interact with each other. It
serves as a blueprint for both the system and the project developing it.
 Common Architectures:
o Layered Architecture: Separates concerns into layers (e.g., presentation,
business logic, data access).
o Microservices Architecture: Breaks down applications into loosely coupled
services that can be developed and deployed independently.
o Event-Driven Architecture: Uses events to trigger and communicate between
decoupled services.
o Client-Server Architecture: Divides tasks between service providers (servers)
and service requesters (clients).
3.3 Outline Programming Strategies

Differentiate Programming Paradigms

 Imperative Programming: Focuses on how to perform tasks using statements that

change a program's state (e.g., C, Fortran).
 Functional Programming: Treats computation as the evaluation of mathematical
functions and avoids changing state (e.g., Haskell, Lisp).
 Declarative Programming: Expresses the logic of a computation without describing its
control flow (e.g., SQL, Prolog).
 Object-Oriented Programming: Organizes code into objects that combine data and
behavior (e.g., Java, C++, Python).

Justify OOP Over Other Paradigms

 Code Reusability: Through inheritance, existing code can be reused, reducing

redundancy.
 Modularity: OOP promotes the creation of modular programs, making it easier to
manage and understand large codebases.
 Flexibility and Maintainability: OOP allows for easier modification and extension of
existing code through polymorphism and encapsulation.
 Real-World Modeling: OOP allows developers to model real-world entities more
intuitively, making it easier to design systems that simulate real-world processes.

3.4 Categorise Methodologies

Software Development Methodologies

1. Waterfall Model:
o Description: A linear and sequential approach where each phase must be
completed before the next begins. It is easy to manage but inflexible to changes.
o Phases: Requirements, Design, Implementation, Testing, Deployment,
Maintenance.
 2. Agile Methodology:
o Description: An iterative approach that promotes flexibility and customer
collaboration. It encourages adaptive planning and evolutionary development.
o Practices: Scrum, Kanban, Extreme Programming (XP).
3. Spiral Model:
o Description: Combines iterative development with the systematic aspects of the
waterfall model. It emphasizes risk assessment and iterative refinement.
o Phases: Planning, Risk Analysis, Engineering, Evaluation.
4. DevOps:
o Description: A methodology that integrates development and operations teams to
enhance collaboration and productivity by automating infrastructure, workflows,
and continuous monitoring.
5. Rapid Application Development (RAD):
o Description: Focuses on quickly building prototypes and iterative development,
allowing for rapid feedback and adjustments.

4.1 Explain Program Structure

Components of a C++ Program Structure

1. Pre-Processor Directives:
o Instructions that are processed before compilation. They include header file
inclusions and macro definitions.
o Example:

cpp

 
 #include <iostream> // Includes the iostream library for input/output

 Global Declarations:
  Declarations of variables and functions that are accessible throughout the program.
Global variables should be used sparingly to avoid unintended side effects.

 Functions:

 Local Declarations: Variables declared within a function, accessible only within that
function.
 Valid C++ Statement: A statement that follows C++ syntax rules and executes correctly.
 Example of a function:

cpp

 
 void greet() {
 std::cout << "Hello, World!" << std::endl;
 }

 Comments:

 Used to explain code and make it more readable. Comments are ignored by the compiler.
 Single-line comment:

cpp

 // This is a single-line comment

 Multi-line comment:
cpp

4.
o /* This is a
o multi-line comment */
o

4.2 Identify Programming Concepts

Outline Programming Errors

1. Syntax Errors: Mistakes in the code that violate the grammatical rules of C++, often
caught at compile time.
2. Runtime Errors: Errors that occur during program execution, such as division by zero or
accessing an out-of-bounds array index.
3. Logical Errors: Errors that produce incorrect results due to flawed logic, not necessarily
causing the program to crash.
4. Linker Errors: Occur when the linker cannot find the definition of a function or variable
referenced in the code.
5. Semantic Errors: Errors where the syntax is correct, but the meaning is not what the
programmer intended.

Declare C++ Identifiers

1. Define Identifier: Names used to identify variables, functions, classes, etc.

2. Predefined and User-Defined Identifiers:
o Predefined: Identifiers provided by C++ (e.g., int, cout).
o User-Defined: Identifiers created by the programmer (e.g., myVariable,
calculateSum).
3. Rules of Naming Identifiers:
o Must start with a letter or underscore.
o Can contain letters, digits, or underscores.
o Cannot use reserved keywords.
o Case-sensitive (e.g., variable and Variable are different).
4. Variable and Constant Identifiers:
o Variables: Identifiers that can change value.
o Constants: Identifiers that cannot change value after initialization (e.g., const int
MAX = 100;).

Explain C++ Data Types

1. Standard Data Types:

 o int: Integer type.
o float: Floating-point type.
o double: Double-precision floating-point type.
o char: Character type.
o bool: Boolean type (true/false).
2. User-Defined Data Types:
o struct: A structure that groups related variables.
o class: A class that encapsulates data and functions.

Apply Operators in C++ Expressions

1. Arithmetic Operators: +, -, *, /, %.
2. Assignment Operator: =.
3. Relational Operators: ==, !=, <, >, <=, >=.
4. Logical Operators: &&, ||, !.
5. Ternary Operator: A shorthand for if-else, e.g., condition ? expr1 : expr2.
6. Comma Operator: Used to separate expressions, evaluates each and returns the last.
7. Dot/member Operator: Used to access members of a struct or class, e.g.,
[Link].

Implement Modularization/Sub-Programming in C++ Programs

1. Define Function: A block of code designed to perform a specific task.

2. Benefits of Using Functions:
o Improved code organization.
o Reusability of code.
o Easier debugging and testing.
3. Implement Predefined and User-Defined Functions:
o Predefined: Functions provided by C++ libraries.
o User-defined: Functions created by the programmer.
4. Distinguish Between Void and Value Returning Functions:
o Void: Functions that do not return a value.
 o Value Returning: Functions that return a value using the return statement.
5. Explain Parameter Passing:
o Pass by Value: Copies the value of an argument into the formal parameter.
o Pass by Reference: Passes the address of the argument, allowing the function to
modify it.
6. Apply Variable Scope and Scope Rules:
o Local Scope: Variables declared within a function.
o Global Scope: Variables declared outside of all functions.
7. Distinguish Between Function Prototype and Function Definition:
o Prototype: Declaration of a function without its body.
o Definition: Complete implementation of the function.
8. Apply Function Overloading:
o Multiple functions can have the same name with different parameter lists.

4.3 Apply Programming Constructs

Explain C++ Control Structures

1. Sequence: The default mode where statements are executed in order.

2. Selection: Allows branching based on conditions using if, else if, else, or switch
statements.
o Example:

cpp

 
 if (condition) {
 // Code to execute if condition is true
 } else {
 // Code to execute if condition is false
 }
 Iteration: Repeated execution of a block of code using loops (for, while, do-while).
  Example:

cpp

3.
o for (int i = 0; i < 10; i++) {
o // Code to execute repeatedly
o }
o

Use Control Structures in C++ Programs

 Control structures can be used to dictate the flow of the program based on conditions and
iterations. They facilitate decision-making and repeated actions.

4.4 Apply Data Structures

Define Data Structure

 A data structure is a way of organizing and storing data in a computer so that it can be
accessed and modified efficiently.

Implement Arrays in Problem Solving

1. Define Array: A collection of elements, all of the same type, stored in contiguous
memory locations.
2. Declare and Initialize Array:
o One-Dimensional Array:

cpp

 int arr[5] = {1, 2, 3, 4, 5};

 Two-Dimensional Array:
cpp
 2.
o int matrix[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
o

3. Manipulate Array Elements:

o Accessing elements: arr[0] refers to the first element.
o Modifying elements: arr[1] = 10; changes the second element.

Implement Structures (Structs) in Problem Solving

1. Define Structure (Struct): A user-defined data type that allows grouping of variables of
different types.

cpp

 struct Person {
std::string name;
int age;
};
 Create Structure: Define an instance of a structure.
cpp
 Person p1;
 Instantiate Structure: Assign values to members.
cpp
3. [Link] = "Alice";
4. [Link] = 30;
5.
6. Manipulate Structure Members: Access and modify members using the dot operator.
7. Implement Structures in Problem Solving: Use structs to manage related data
logically.

Implement Classes in Problem Solving

1. Define Class: A blueprint for creating objects that encapsulates data and methods.
 cpp

 class Car {
public:
std::string brand;
void honk() {
std::cout << "Honk!" << std::endl;
}
};
 Create Class: Define the class structure.
 Instantiate Class: Create objects from the class.
cpp
3. Car myCar;
4. [Link] = "Toyota";
5. [Link]();
6.
7. Overload Class Methods: Define multiple methods with the same name but different
parameters.

Implement File Streams in C++ Programs

1. Define Binary and Text Files:

o Text Files: Store data in human-readable format.
o Binary Files: Store data in a format specific to the system, not human-readable.
2. Describe File Streams: Objects used to handle input and output operations with files.
3. Create Text Files:

cpp

 std::ofstream outFile("[Link]");
outFile << "Hello, World!";
[Link]();
 Explain File Opening Modes:
  ios::in: Open for input.
 ios::out: Open for output (create if not exists).
 ios::app: Append to the end of the file.

 Perform Write and Read Operations on Files:

 Write:

cpp

 std::ofstream outFile("[Link]");
outFile << "Writing to file.";
[Link]();
 Read:
cpp

5.
o std::ifstream inFile("[Link]");
o std::string line;
o while (getline(inFile, line)) {
o std::cout << line << std::endl;
o }
o [Link]();
o