INTRODUCTION TO PROGRAMMING

Computer programming is the process of designing, writing, testing, debugging, and

maintaining the code that makes up software applications, systems, or other computing
functionalities. It involves using programming languages to create instructions that computers
can understand and execute.
Key Components of Computer Programming:
1. Problem Analysis: Understanding the problem that needs to be solved and defining
clear goals for the software or application.
2. Algorithm Design: Developing step-by-step procedures or formulas (algorithms) to
solve the problem.
3. Coding: Writing the actual program using a programming language (e.g., Python,
Java, C++, JavaScript).
4. Testing: Running the program to ensure it works correctly and meets the desired
specifications.
5. Debugging: Identifying and fixing errors (bugs) in the code.
6. Maintenance: Updating and modifying the program over time to fix issues, add
features, or adapt to new requirements.

EXAMPLES OF PROGRAMMING LANGUAGES

General-Purpose Languages
 Python: Easy to learn; used in web development, data analysis, artificial intelligence
(AI), and automation.
 Java: Known for portability; widely used in enterprise applications, Android
development, and web development.
 C: A foundational language; often used in system programming and embedded
systems.
 C++: An extension of C; used in game development, high-performance applications,
and system software.
 Ruby: Known for simplicity and productivity; often used in web development (e.g.,
Ruby on Rails framework).
 Visual Basic
Web Development
 JavaScript: The core language for building interactive websites; used with HTML
and CSS.
 TypeScript: A superset of JavaScript that adds static typing, used for scalable web
applications.
 PHP (Personal Home Page): Often used for server-side web development (e.g.,
WordPress).
 HTML and CSS: Technically markup and styling languages, but essential for web
content.
Mobile Development
  Swift: Used for iOS and macOS app development.
 Kotlin: Officially supported for Android development.
 Dart: Primarily used with the Flutter framework for cross-platform apps.
Data Science and AI
 R: Specialized for statistical computing and graphics.
 MATLAB: Used in engineering, scientific research, and data visualization.
 Julia: Designed for high-performance numerical and scientific computing.
Systems and Embedded Programming
 Assembly: Low-level programming for hardware-specific tasks.
 Rust: Focused on performance and safety; ideal for systems programming.
 Go (Golang): Developed by Google for scalable and efficient applications.
Database Programming
 SQL (Structured Query Language): Used to manage and query relational databases.
 PL/SQL: Oracle’s extension of SQL for procedural tasks.
Game Development
 C#: Frequently used with the Unity game engine.
 C++: Used for creating high-performance games with engines like Unreal.
Scripting and Automation
 Bash/Shell: Automating tasks in Unix/Linux environments.
 Perl: Known for text processing and system administration.
 PowerShell: Automation on Windows systems.
Other Programming Languages
 Prolog: Used in artificial intelligence and logic programming (e.g., expert systems).
 COBOL: Used in legacy business systems, especially in finance and government.
 Lisp: One of the oldest programming languages, popular in AI research.
 ADA
 QBASIC (QUICK BEGINNERS’S ALL-PURPOSE SYMBOLIC INSTRUCTION
CODE)

Common Programming Languages:

 High-level languages: Python, Java, JavaScript, Ruby, C#
 Low-level languages: Assembly, C
 Specialized languages: R (for statistics), MATLAB (for engineering), SQL (for
databases)
Why Learn Computer Programming?
 Problem-solving skills: Programming sharpens logical and analytical thinking.
 Versatility: It's used in various fields like web development, data analysis, artificial
intelligence, and game development.
  Career opportunities: Programmers are in high demand in industries like technology,
healthcare, finance, and education.

FACTORS TO CONSIDER WHEN SELECTING A GOOD PROGRAMMING

LANGUAGE
1. Project Requirements
 Nature of the Project:
o Web, mobile, desktop, game development, or embedded systems?
o Example: JavaScript for web, Swift for iOS, C++ for game development.
 Performance Needs:
o High-performance requirements (e.g., real-time systems or simulations) may
need low-level languages like C++ or Rust.
o For general-purpose applications, higher-level languages like Python or Java
are often sufficient.
 Domain-Specific Needs:
o Example: Python or R for data science, Solidity for blockchain, MATLAB for
engineering simulations.
2. Ease of Use and Learning Curve
 Developer Familiarity:
o Choose a language that aligns with your or your team’s existing knowledge to
minimize the learning curve.
 Simplicity and Readability:
o Python and Ruby are known for their simple syntax and readability, making
them ideal for beginners or rapid development.
3. Performance and Efficiency
 Speed of Execution:
o For computationally intensive tasks, compiled languages like C++ or Rust are
better than interpreted ones like Python.
 Memory Management:
o Languages like Rust offer advanced memory safety features, while others, like
Java, manage memory through garbage collection.
4. Scalability and Future Growth
 Scalability:
o For systems expected to handle growth in users or data, languages like Java,
Go, or Python are ideal due to their robust ecosystems.
 Long-Term Viability:
o Select a language with active development and strong community support to
ensure it remains relevant.
5. Community Support and Ecosystem
  Active Community:
o Languages like Python, JavaScript, and Java have extensive communities that
can help resolve issues quickly.
 Availability of Libraries and Frameworks:
o Python (e.g., TensorFlow, Django), JavaScript (e.g., React, Node.js), and Java
(e.g., Spring) have robust ecosystems.
6. Development Speed
 Rapid Prototyping:
o Languages like Python or Ruby enable quick development, making them
suitable for startups or proof-of-concept projects.
 Tooling and IDE Support:
o Languages with excellent tools (e.g., PyCharm for Python, Visual Studio for
C#) can accelerate development.
7. Platform and Compatibility
 Cross-Platform Support:
o Java, Python, and JavaScript are platform-independent.
o Native languages like Swift (iOS) and Kotlin (Android) may be better for
platform-specific apps.
 Integration with Existing Systems:
o Consider languages compatible with the current tech stack.
8. Cost and Resources
 Open Source vs. Proprietary:
o Many languages (Python, JavaScript, Ruby) are open source, reducing costs.
o Some languages or their tools (e.g., MATLAB) may require licenses.
 Hardware Requirements:
o Lightweight languages (e.g., C) may be better for systems with limited
resources.
9. Security
 Built-in Security Features:
o Rust, for instance, is designed with memory safety in mind.
o Java has robust security features through its virtual machine (JVM).
 Community and Updates:
o Languages with active communities (e.g., Python) receive timely security
updates.
10. Team and Collaboration
 Team Expertise:
o Align the choice with your team’s expertise to reduce onboarding time.
 Availability of Developers:
 o Popular languages (e.g., JavaScript, Python, Java) make it easier to find skilled
developers.
11. Industry Trends and Demand
 Job Market and Career Growth:
o If hiring or skill-building is a consideration, choose languages with strong
demand, like Python, JavaScript, or Java.
 Emerging Technologies:
o Stay ahead with languages suited for AI (Python), blockchain (Solidity), or
cloud computing (Go).
12. Maintainability
 Code Readability and Maintainability:
o A language with clear syntax and strong documentation ensures long-term
maintainability.
o Example: Python and Ruby are known for their clean syntax, while C++ may
require more effort.
 Testing and Debugging Tools:
o Look for languages with integrated testing and debugging support.
Summary Checklist:
Factor Examples
Performance C++, Rust for speed; Python for ease.
Ease of Use Python, Ruby for simplicity; C for advanced control.
Scalability Java, Go for large-scale applications.
Community Support Python, JavaScript have large active communities.
Domain Fit R for statistics, Solidity for blockchain, Swift for iOS.
Tooling and Libraries TensorFlow for AI (Python), React for UI
(JavaScript).
Cost Open source: Python, Ruby; Proprietary: MATLAB.
Security Rust for memory safety; Java for robust environments.

FEATURES OF PROGRAMMING LANGUAGES

1. Data Types
Data types define the kind of data a variable can hold. They are fundamental to every
programming language.
 Primitive Data Types:
o Integer: Whole numbers (e.g., 1, 42).
o Float/Double: Decimal numbers (e.g., 3.14, 0.001).
o Character: Single character (e.g., 'A', 'z').
o Boolean: True or false values (true, false).
  Composite Data Types:
o Arrays: Collection of elements of the same type (e.g., [1, 2, 3]).
o Structures/Records: User-defined data types to group related variables.
 Abstract Data Types:
o Lists, stacks, queues, and other data structures supported by libraries.
2. Constants and Variables
 Constants:
o Immutable values that do not change during the program's execution.
o Example: const PI = 3.14159 in JavaScript.
 Variables:
o Named memory locations that hold data which can change during execution.

Example:
x = 10 “A variable holding an integer”
3. Expressions and Assignments
 Expressions:
o A combination of variables, constants, and operators that evaluates to a value.
o Example:
result = (x + y) * z

 Assignments:
o Statements that assign the value of an expression to a variable.
int age = 25; “Assigns the value 25 to the variable age”

4. Operators
Operators perform operations on variables and values.
 Arithmetic Operators: +, -, *, /, %.
 Relational Operators: ==, !=, >, <, >=, <=.
 Logical Operators: && (AND), || (OR), ! (NOT).
 Bitwise Operators: &, |, ^, ~, <<, >>.
 Assignment Operators: =, +=, -=, *=, /=.

5. Procedures and Functions

 Procedures: Blocks of reusable code that perform a specific task but do not return a
value.
Example
def greet(name):
print(f"Hello, {name}!")
 Functions: Blocks of code that perform a task and return a value.
Example:
def add(a, b):
return a + b

6. Input/Output Statements
 Input Statements: Allow programs to take user input.
Example:
name = input("Enter your name: ")
 Output Statements: Display results to the user.
Example:
print("Hello, World!")

7. Control Structures
Control structures dictate the flow of a program.
 Conditional Statements:
Example:
if age >= 18:
print("You are an adult.")
else:
print("You are a minor.")
 Loops:
o For Loop:
for i in range(5):
print(i)
o While Loop:
while x > 0:
x -= 1
8. Error Handling
Mechanisms for managing runtime errors.
Example (Python):
try:
result = 10 / 0
except ZeroDivisionError:
print("Cannot divide by zero.")

PROGRAMMING DEVELOPMENT LIFE CYCLE (PDLC)

The Programming Development Life Cycle (PDLC) can be broken into seven distinct
stages, providing a structured approach to software development. Here are the seven stages in
detail:
1. Problem Definition
 Objective: Clearly understand and define the problem that the program aims to solve.
 Key Activities:
o Identify the purpose and scope of the program.
o Collaborate with stakeholders to gather requirements.
o Define the problem in measurable terms.
 Outcome: A problem statement and a requirements document.
o Example: "Develop a system to manage student records, including adding,
deleting, and searching for student information."
2. Analysis
 Objective: Analyze the requirements and feasibility of the solution.
 Key Activities:
o Break down the requirements into smaller, manageable components.
o Determine the resources needed (time, tools, manpower).
o Perform feasibility studies (technical, economic, legal, and operational).
 Outcome: A detailed analysis report outlining project feasibility and a refined
requirements specification.
3. Design
 Objective: Create a blueprint for the program to guide the coding phase.
 Key Activities:
o Develop algorithms, flowcharts, and pseudocode to plan program logic.
o Design system architecture, including data structures, modules, and interfaces.
o Define input/output formats and user interactions.
 Outcome: A system design document with clear workflows, diagrams, and program
structure.
o Example: A UML diagram for a student management system.
4. Coding (Implementation)
 Objective: Translate the design into actual source code.
 Key Activities:
o Select the appropriate programming language.
 o Write code following best practices and the design plan.
o Include comments and documentation for maintainability.
 Outcome: A working program or prototype.
o Example: Writing the Python code for adding and retrieving student records.
5. Testing
 Objective: Ensure the program is error-free and meets requirements.
 Key Activities:
o Perform different types of testing:
 Unit Testing: Test individual components.
 Integration Testing: Test how modules interact.
 System Testing: Test the program as a whole.
 User Acceptance Testing (UAT): Validate the program with end users.
o Debug any issues found during testing.
 Outcome: A thoroughly tested and validated program.
o Example: Fixing a bug that causes incorrect student data retrieval.
6. Deployment
 Objective: Deliver the program to end users and ensure its operational.
 Key Activities:
o Install the program on the target environment (e.g., servers, user devices).
o Configure the system and perform a final round of testing in the live
environment.
o Provide user training or documentation, if necessary.
 Outcome: The program is live and available for users.
o Example: Deploying a web-based student management system to a cloud
server.
7. Maintenance
 Objective: Keep the program functional, secure, and up-to-date over time.
 Key Activities:
o Fix bugs and resolve issues reported by users.
o Update the program to adapt to new requirements or technologies.
o Monitor system performance and scalability.
 Outcome: An updated and improved program over its lifespan.
o Example: Adding new features like generating student progress reports.
Summary Table of the Seven PDLC Stages
Stage Objective Outcome
1. Problem Define what the program will Problem statement,
 Definition solve. requirements document.
2. Analysis Analyze feasibility and refine Analysis report, refined
requirements. specifications.
3. Design Plan the program structure and Design documents, algorithms,
logic. workflows.
4. Coding Write and implement the program. A functional program or
prototype.
5. Testing Ensure the program is error-free Debugged, validated program.
and functional.
6. Deployment Make the program available to Deployed, live application.
users.
7. Maintenance Keep the program functional over Updated, improved program.
time.

DIFFERENCES BETWEEN DEBUGGING AND TESTING

Debugging and Testing are both critical activities in software development, but they serve
different purposes and occur at different stages of the development process. Here's a
breakdown of their key differences:
1. Purpose
 Testing:
o The primary goal of testing is to verify that the software behaves as expected
and meets the requirements. It focuses on identifying bugs, defects, or issues
before the software is released.
o Testing is typically proactive, aiming to prevent problems by evaluating the
program’s behavior under different conditions.
 Debugging:
o Debugging is the process of locating, identifying, and fixing errors or bugs
that have been discovered during testing or operation. It focuses on correcting
issues identified in the code.
o Debugging is reactive, as it happens after a bug or error has been found.
2. When They Occur
 Testing:
o Testing occurs before or during the execution of the software, usually in the
early stages of development or whenever changes are made (e.g., after writing
code for a new feature).
o Testing can be performed at various levels, such as unit testing, integration
testing, and system testing.
 Debugging:
o Debugging occurs after errors or bugs have been detected, usually during or
after the testing phase.
 o Debugging is often done in response to issues found during testing or when
users encounter problems during the software’s operation.
3. Focus
 Testing:
o Testing focuses on ensuring that the software works correctly, performs well,
and meets the required functional and non-functional specifications (e.g.,
security, usability).
o Testers typically run the program and check its behavior under various
scenarios to identify bugs.
 Debugging:
o Debugging focuses on isolating and fixing specific problems in the code.
When an issue is detected, the developer traces the program's execution to find
the root cause of the error and applies a fix.
4. Tools Used
 Testing:
o Test cases are executed using test frameworks and tools (e.g., JUnit,
Selenium, TestNG) to automatically or manually test the software.
o Testing tools might simulate different scenarios to check the correctness of the
software.
 Debugging:
o Debugging tools (e.g., IDE debuggers like Visual Studio, Eclipse, or GDB)
allow developers to inspect code during execution, set breakpoints, step
through code, and monitor variables to understand how and why an issue
occurred.
5. Outcome
 Testing:
o The outcome of testing is a test report that highlights which parts of the
program pass or fail under different conditions.
o Testing may identify a bug, but it doesn’t provide a fix. Instead, it provides
information about what went wrong.
 Debugging:
o The outcome of debugging is a corrected or fixed program. Debugging
results in resolving the bug and making the code run as expected.
o Debugging usually involves modifying the code to eliminate the error.
6. Type of Work
 Testing:
o Testing can be done by QA testers or developers and often involves running
the software through various scenarios to validate functionality, performance,
and security.
o The goal is to check if the software meets user requirements.
 Debugging:
 o Debugging is typically carried out by developers who identify why the
software is malfunctioning and work on fixing the issue in the source code.
o It involves hands-on modification of the code and working with development
tools to pinpoint and correct the root cause.
Summary of Key Differences
Aspect Testing Debugging
Purpose To verify that the software works To identify and fix bugs or errors in
as expected. the code.
When It Before or during development After a bug has been detected,
Occurs (often in cycles). typically post-testing.
Focus Checking software functionality Finding and fixing specific issues in
and correctness. the code.
Tools Used Test frameworks, automation tools, Debuggers, breakpoints, code
test scripts. analyzers.
Outcome Test results or reports on program A fixed and corrected program.
behavior.
Who Does It QA testers, developers, automated Developers.
systems.

ALGORITHMS AND FLOWCHART

An algorithm is a well-defined, step-by-step procedure or set of instructions used to solve a
problem or perform a task. It provides a clear and unambiguous way to carry out a specific
operation, such as sorting data, searching for an element, or calculating a value.
Key Characteristics of an Algorithm:
1. Finiteness:
o An algorithm must have a finite number of steps and should eventually
terminate after a defined set of operations. It can't run indefinitely.
2. Definiteness:
o Every step in the algorithm must be precisely defined. There should be no
ambiguity about what should be done at each step.
3. Input:
o An algorithm takes zero or more inputs. These inputs are the values or data
provided to the algorithm to work with.
4. Output:
o An algorithm produces at least one output, which is the result of the
computations or processes performed by the algorithm.
5. Effectiveness:
o Each step of an algorithm must be basic enough to be carried out, in principle,
by a human or machine within a finite amount of time. The steps should be
feasible and achievable.
6. Generality:
 o An algorithm should be applicable to a broad class of problems, not just a
specific instance.
Why Are Algorithms Important?
 Efficiency: Well-designed algorithms can reduce the time and resources needed to
complete a task.
 Correctness: An algorithm ensures the problem is solved accurately and consistently
every time.
 Reusability: Once an algorithm is designed, it can be reused in different situations or
for different types of problems.
 Optimization: Algorithms help to find optimal solutions, such as the shortest path in
a graph or the most efficient way to sort data.

TECHNIQUES FOR REPRESENTING ALGORITHM

When representing algorithms, there are several techniques used to express the steps and
logic involved. These techniques vary in terms of formality, expressiveness, and level of
detail. The three most common techniques for representing algorithms are Pseudocode,
Flowcharts, and Actual Code. Each of these techniques serves a different purpose and is
suitable for different stages of algorithm design and development.
1. Pseudocode
Definition:
Pseudocode is an informal, human-readable way to describe the steps of an algorithm
without adhering to the syntax of any particular programming language. It uses simple
language and a structured format to represent the logic of an algorithm, making it easier
to understand the procedure.
Purpose:
 To outline the high-level steps of an algorithm in an easy-to-understand manner.
 To serve as a blueprint for developing the actual code in a programming language.
Features:
 Uses plain language mixed with simple programming constructs like if, for, while,
input, output, etc.
 Not executable, but can be easily translated into code.
 Focuses on the algorithm's logic rather than syntax.
Example: Algorithm to find the largest number in a list:
Python
Start
Set max to the first number in the list
For each number in the list:
If the number is greater than max:
Set max to that number
Print max
End

Advantages:
 Easy to understand and follow, even for non-programmers.
 Language-agnostic, so it can be translated into any programming language.
 Simplifies complex logic by breaking it down into steps.
Disadvantages:
 Not executable directly; it needs to be converted into code.
 Can be less precise in some situations, especially for complex algorithms.

2. Flowcharts
Definition:
A flowchart is a graphical representation of an algorithm that uses symbols and arrows to
depict the flow of control through the steps of the algorithm. Each step is represented by a
specific shape, and arrows indicate the direction of the process.
Purpose:
 To visually represent the flow of control and decision-making in an algorithm.
 To make the algorithm easier to follow, especially for complex processes.
Features:
 Uses specific shapes to represent different types of operations:
o Oval: Start and end of the process.
o Rectangle: Process or operation (e.g., calculation, assignment).
o Diamond: Decision point (e.g., if-else statements).
o Parallelogram: Input/output operations (e.g., reading input, printing output).
 Arrows show the order of execution.
Example:
Flowchart to find the largest number in a list:
{
}

Advantages:
 Ideal for representing algorithms with complex decision-making and control flow.
 Helps visualize the entire process at a glance.
 Useful for both technical and non-technical audiences.
Disadvantages:
 Can become cluttered and difficult to understand for large algorithms.
 Not easily modifiable or reusable once created.
3. Actual Code
Definition:
Actual code is a precise, executable representation of an algorithm written in a specific
programming language. It is the final implementation of the algorithm that can be run and
tested on a computer.
Purpose:
 To implement the algorithm so that it can be executed and tested for correctness.
 To provide a detailed, language-specific description of the algorithm.
Features:
 Written in a specific programming language (e.g., Python, Java, C++).
 Includes all the syntax and rules of the chosen language.
 Can be executed directly on a computer to solve the problem.
Example (Finding the largest number in Python):
python
def find_largest(numbers):
max_num = numbers[0] # Initialize max to the first element
for num in numbers: # Loop through each number in the list
if num > max_num: # If the current number is larger than max_num
max_num = num # Update max_num to the current number
return max_num # Return the largest number
Advantages:
 Precise and executable; can be tested to check for correctness.
 Detailed, specifying exactly how the algorithm is to be implemented.
 Allows for optimization and real-world usage.
Disadvantages:
 Specific to a programming language; not easily portable to other languages.
 Requires knowledge of programming to understand and write.
 Can be more complex to read and understand compared to pseudocode or flowcharts,
especially for beginners.

Comparison of the Techniques

Technique Description Best For Advantag Disadvantag
 es es
Pseudoco Informal, High-level Easy to Not
de structured algorithm read and executable,
representati design and understand lacks
on of logic. explanation. , language- precision in
agnostic. complex
algorithms.
Flowchart Visual Visualizing Easy to Can become
representati control flow follow and complex for
on using and decision- helps large
shapes and making. visualize algorithms,
arrows. the not easily
process. modifiable.
Actual Precise, Final Exact, Specific to a
Code executable implementati executable, language,
code in a on and testable. requires
programmin testing. programming
g language. knowledge.

When to Use Each Technique:

1. Pseudocode:
o Best when you are designing the algorithm and want to focus on the logic
without worrying about language-specific syntax.
o Useful for brainstorming or teaching algorithms.
2. Flowcharts:
o Ideal when you need to illustrate the flow of control and decision-making
visually, especially for complex problems.
o Useful when explaining algorithms to people who are not familiar with
coding.
3. Actual Code:
o Used when the algorithm is ready for implementation and testing.
o The final step when an algorithm needs to be executed on a computer.

QBASIC

Step 1: Introduction to QBasic

What QBasic Is
 QBasic (Quick Beginners' All-purpose Symbolic Instruction Code) is an easy-to-learn
programming language.
 It is interpreter-based (executes line by line).
 It is used for basic logic building and problem-solving skills.
Note: "QBasic is like teaching a robot step-by-step instruction."

Set Up QBasic on Their Computers

1. Download QBasic: Get QBasic 1.1 or QB64 (modern version).
2. Installation: Run in the folder
3. Opening the IDE: Explain the interface: Editor, Menu, Output Screen.

A. Understanding the QBasic Environment

Before coding, students should:
 Download and install QBasic (either QBasic 1.1 or QB64).
 Learn how to open, write, save, and run programs.
 Understand the QBasic interface:
o Editor Window (for writing code).
o Output Window (where results appear).
o Menu Options (for running, saving, and debugging).

Main Components of the QBasic Window

1. Title Bar
Located at the very top of the window, it displays:
 The name of the program file currently open.
 The QBasic version (e.g., "QBasic 1.1").

2. Menu Bar
Below the title bar, it contains drop-down menus with important options:
Menu Function
File Open, Save, Print, Exit QBasic
Edit Copy, Paste, Delete, Find text
View Show/hide debugging tools
Search Find and replace words in code
Run Execute the program (F5 key)
Debug Step-by-step execution for error fixing
Options Customize settings like screen color
Help Displays documentation and guidance

Tip: Most commonly used options are under File, Run, and Debug menus.

3. Program Editor Window (Text Area)

This is the largest part of the QBasic window. It is where you write and edit code.
 It has a blue background (default color).
  It does not support a mouse—you must use the keyboard to navigate.
Tip: The cursor blinks where you are typing. You can move around using arrow keys.

4. Immediate Mode (Optional Feature in Some Versions)

Some versions (like QB64) include an Immediate Mode at the bottom.
 You can type and execute QBasic commands directly without writing a full
program.
Example: If you type:
PRINT 2 + 2
It immediately shows the result: 4.

5. Output Screen (When Running a Program)

When you run a program, QBasic switches to the output screen to display results.
 After execution, press any key to return to the editor.
Example: Running this code:
PRINT "Hello, World!"
Shows this output:
Hello, World!

6. Status Bar (Bottom of the Window)

Displays helpful information about your code, such as:
 Current cursor position (Line Number, Column Number).
 Error messages (if something is wrong in the code).
Tip: If QBasic detects an error, it will highlight the mistake and provide a message in the
status bar.
Keyboard Shortcuts for QBasic Window
Shortcut Function
F5 Run the program
Shift + F5 Stop execution
F6 Switch between code & output screen
F2 Open a new program
Ctrl + S Save program
Ctrl + O Open an existing program
Alt + F4 Exit QBasic

Functions of "OK" in the QBasic Status Bar

1️Indicates Readiness
  If "OK" is displayed at the bottom, it means QBasic is ready to accept commands
or new code.
 You can start typing your program without issues.
2️ Confirms Successful Execution
 After running a program, if no errors are found, QBasic returns to the editor and
displays "OK" at the bottom.
 This means the program ran successfully, and you can continue coding.
3️ Clears Error Messages
 If there was an error in the code, QBasic shows an error message in the status bar.
 Once the error is fixed and the program is run again, "OK" appears, confirming there
are no issues.

When Does "OK" Disappear?

 If you are typing a command or running a program, "OK" disappears.
 If there is an error in your code, "OK" is replaced with an error message.

Step 2: Start with Basic Concepts

First Program: "Hello, World!"
Introduce the PRINT command.
PRINT "Hello, World!"
 Teach them to run the program (F5 key in QBasic).
 Explain how QBasic executes line by line.
Tip: Let students modify the text and observe changes.

Input and Output

 Teach INPUT for user interaction.
INPUT "What is your name? ", name$
PRINT "Hello, "; name$
 Explain difference between numbers and strings ($ for strings).
Activity: Let students create a simple name and age display program.

Step 3: Control Structures

Conditional Statements (IF...THEN...ELSE)
Example: Checking Even or Odd Number
INPUT "Enter a number: ", num
IF num MOD 2 = 0 THEN
 PRINT "Even number"
ELSE
PRINT "Odd number"
END IF

Activity: Ask students to create a simple grading system using IF-THEN-ELSE.

Loops (FOR, WHILE, DO WHILE)

FOR Loop Example: Print numbers 1 to 5
FOR i = 1 TO 5
PRINT "Number: "; i
NEXT i
Activity: Have students create a countdown timer using a loop.

Step 4: Fun with Small Projects

1. Simple Calculator (Using INPUT, IF, and PRINT)
2. Guess the Number Game (Using RND for random numbers)
3. Multiplication Table Generator (Using FOR loop)
Tip: Encourage students to experiment by modifying existing programs.

Step 5: Debugging and Best Practices

Common Errors and How to Fix Them
 Syntax Errors: Misspelled commands (PRNT instead of PRINT).
 Logic Errors: Incorrect calculations (x - y instead of x + y).
 Infinite Loops: Missing exit conditions in loops.
Activity: Give them a faulty program and ask them to debug it.

Step 6: Encourage Creativity & Exploration

 Introduce Graphics Mode (Using LINE, CIRCLE).
 Assign a mini-project (like a quiz game or animation).
 Let students share and present their project

In QBasic, DIM (short for Dimension) is a statement used to declare variables and specify
their data types. It is especially useful for arrays and structured programming.
Syntax:
DIM variableName AS DataType
or
DIM arrayName(size) AS DataType

Common Data Types in QBasic

Data Type Description Example
INTEGER Whole numbers (-32,768 to DIM age AS INTEGER
32,767)
SINGLE Decimal numbers (floating point) DIM price AS SINGLE
DOUBLE High-precision decimal numbers DIM distance AS DOUBLE
STRING Text (up to 32,767 characters) DIM name AS STRING
BOOLEAN True/False values (not native, but DIM isPassed AS INTEGER (using 0
can be simulated) for False, 1 for True)

Examples of DIM in QBasic

1. Declaring Simple Variables
CLS
DIM age AS INTEGER
DIM name AS STRING
DIM price AS SINGLE

age = 25
name = "John"
price = 99.99

PRINT "Name:", name

PRINT "Age:", age
PRINT "Price: $"; price
END
Output:
Name: John
Age: 25
Price: $99.99

2. Declaring and Using an Array

CLS
DIM scores(4) AS INTEGER ' Declare an array with 5 elements (0 to 4)

scores(0) = 90
scores(1) = 85
scores(2) = 78
scores(3) = 88
scores(4) = 92

PRINT "Student Scores:"

FOR i = 0 TO 4
PRINT "Score"; i + 1; ":", scores(i)
NEXT i
END
Output:
Student Scores:
Score 1: 90
Score 2: 85
Score 3: 78
Score 4: 88
Score 5: 92
Explanation:
 DIM scores(4) AS INTEGER declares an array with 5 elements (scores(0) to
scores(4)).
 A FOR loop is used to display the scores.

3. Declaring Multi-Dimensional Arrays

CLS
DIM matrix(2,2) AS INTEGER ' 3x3 matrix (0 to 2,0 to 2)

matrix(0,0) = 1
matrix(0,1) = 2
matrix(0,2) = 3
matrix(1,0) = 4
matrix(1,1) = 5
matrix(1,2) = 6
matrix(2,0) = 7
matrix(2,1) = 8
matrix(2,2) = 9

PRINT "Matrix Elements:"

FOR i = 0 TO 2
FOR j = 0 TO 2
PRINT matrix(i, j);
NEXT j
PRINT
NEXT i
END
Output:
Matrix Elements:
1 2 3
4 5 6
7 8 9
Explanation:
 DIM matrix(2,2) AS INTEGER creates a 3x3 matrix.
 Two nested FOR loops print the matrix properly.

Why Use DIM?

✔ Helps define variable types, preventing errors.
✔ Improves memory management, especially for arrays.
✔ Makes the program more organized and readable.

The PRINT USING command is used to format output in a structured way. It helps display
numbers, strings, and other data in a readable and organized format.
Uses of PRINT USING in QBasic:
1. Controlling Decimal Places – It allows displaying numbers with a fixed number of
decimal places.
2. Aligning Text and Numbers – Ensures proper spacing and alignment for output.
3. Adding Special Symbols – Can include currency symbols ($), percentage signs (%),
and other characters.
4. Leading Zeros and Spaces – Helps in formatting numbers with leading zeros or
fixed-width spaces.
5. Tabular Display – Useful for printing tables in a structured way.
Examples of PRINT USING
Example 1: Formatting a Number with Two Decimal Places
CLS
DIM price AS SINGLE
price = 123.456
PRINT USING "The price is $##.##"; price
END
Output:
The price is $123.46
The number is rounded to two decimal places.

Example 2: Aligning Text and Numbers

CLS
DIM name AS STRING
DIM score AS SINGLE
name = "Alice"
score = 98.5
PRINT USING "Player: \_______ Score: ##.##"; name; score
END
Output:
Player: Alice Score: 98.50
The \_______ ensures that the name aligns properly.

Example 3: Displaying Numbers with Leading Zeros

CLS
DIM num AS INTEGER
num = 45
PRINT USING "Your ID is: 000#"; num
END
Output:
Your ID is: 0045
The 000# ensures leading zeros are added.

Formatting Symbols in PRINT USING

 Symbo Description
l
# Represents a digit (ignores leading zeros)
0 Forces leading zeros
. Decimal point
, Thousands separator
+ or - Displays positive or negative signs
\\ Used for displaying text within quotes

ARRAYS
An array in QBasic is a collection of multiple values stored under a single variable name,
where each value is accessed using an index (subscript). Arrays are useful for storing lists,
tables, and structured data.
Why Use Arrays?
✔ Stores multiple values in one variable.
✔ Reduces repetition – avoids declaring multiple separate variables.
✔ Easier to process data using loops.
✔ Efficient memory usage for large sets of data.
Declaring an Array in QBasic
DIM arrayName(size) AS DataType
 arrayName → Name of the array.
 size → Number of elements (index starts from 0 by default).
 DataType → Type of data stored (e.g., INTEGER, STRING, SINGLE).
Types of Arrays in QBasic
1. One-Dimensional (1D) Arrays
A simple list of values stored in a sequence.
Example: Storing 5 student scores
CLS
DIM scores(4) AS INTEGER ' Declares an array with 5 elements (0 to 4)

scores(0) = 90
scores(1) = 85
scores(2) = 78
scores(3) = 88
scores(4) = 92
PRINT "Student Scores:"
FOR i = 0 TO 4
PRINT "Score"; i + 1; ":", scores(i)
NEXT i
END
Output:
Student Scores:
Score 1: 90
Score 2: 85
Score 3: 78
Score 4: 88
Score 5: 92
Explanation:
 scores(4) means the array has 5 elements (0 to 4).
 A FOR loop prints each score efficiently.

2. Two-Dimensional (2D) Arrays (Matrix)

A table with rows and columns.
Example: Storing a 3×3 matrix
CLS
DIM matrix(2,2) AS INTEGER ' 3x3 matrix (0 to 2, 0 to 2)

matrix(0,0) = 1
matrix(0,1) = 2
matrix(0,2) = 3
matrix(1,0) = 4
matrix(1,1) = 5
matrix(1,2) = 6
matrix(2,0) = 7
matrix(2,1) = 8
matrix(2,2) = 9

PRINT "Matrix Elements:"

FOR i = 0 TO 2
FOR j = 0 TO 2
 PRINT matrix(i, j);
NEXT j
PRINT
NEXT i
END
Output:
Matrix Elements:
1 2 3
4 5 6
7 8 9
Explanation:
 matrix(2,2) creates a 3×3 table.
 Nested loops print the matrix in row-column format.

3. Dynamic Arrays (REDIM)

If you don’t know the size of an array initially, use REDIM to resize it later.
Example: Creating an array dynamically
CLS
DIM n AS INTEGER
INPUT "Enter number of elements: ", n
REDIM numbers(n) AS INTEGER ' Resizes the array

FOR i = 1 TO n
INPUT "Enter number: ", numbers(i)
NEXT i

PRINT "You entered:"

FOR i = 1 TO n
PRINT numbers(i)
NEXT i
END
Explanation:
 REDIM numbers(n) resizes the array based on user input.
 Useful when array size is not fixed.
Array Indexing Rules in QBasic
Default index starts from 0.
DIM a(4) AS INTEGER → Has 5 elements (a(0) to a(4)).
Use OPTION BASE 1 to start index from 1 instead of 0.

Advantages of Arrays
✔ Organized storage of multiple values.
✔ Easy access using loops.
✔ Efficient compared to multiple separate variables.
✔ Supports multi-dimensional storage (tables, grids).