ADDIS ABABA

UNIVERSITY - EiABC
COMPUTER PROGRAMMING ASSIGNMENT 1

PREPARED BY: Yosef Roba

UGR/1556/15 SECTION 2
Table of Contents
1)Distinctions ................................................................................................................. 2
2)8-bit ASCII ................................................................................................................... 4
3)Programmability .......................................................................................................... 4
4) Algorithms .................................................................................................................. 6
5) Bugs, Debugging and Errors ....................................................................................... 10
REFERENCES ............................................................................................................... 18

1
1)Distinctions
The distinctions between Syntax, Semantics and Static Semantics are mainly
viewed on their fields of focus i.e. what they focus on.
i. Syntax:

• Focus: The structure of a language.

• Analogy: Think of it like the grammar rules of a language. It dictates how
words and symbols are arranged to form meaningful units (like sentences or
expressions).
Example: In English, "Abebe sat on the grass" is syntactically correct, while "Sat
Abebe on the grass the" is not.
ii. Semantics:

• Focus: The meaning of a language.

• Analogy: Think of it like the dictionary definition of words and how they
relate to each other in a sentence. It's about understanding the meaning
conveyed by a correctly structured sentence.
Example: "Abebe sat on the grass" has a clear meaning, while "Abebe sat on the
moon" is semantically incorrect because Abebe cannot sit on the moon.
iii. Static Semantics:

• Focus: The rules that ensure a program is well-formed and consistent before
it's executed.
• Analogy: Think of it like the "type checking" that happens in programming
languages. It ensures that variables are used in a way that makes sense and
avoids potential errors.
Example: In many programming languages, you can't add a number to a string
directly. This is a static semantic rule that prevents a program from executing with
an error.

2
Key Distinctions:
Syntax is about the form, semantics is about the meaning.
Static semantics is a bridge between syntax and semantics. It ensures that the
structure of a program (syntax) is consistent with its intended meaning (semantics).

In summary:
Syntax: "Abebe sat on the grass" is grammatically correct.
Semantics: "Abebe sat on the grass" makes sense.
Static Semantics: A program that tries to add a number to a string would be
flagged as a static semantic error.

3
2)8-bit ASCII
Here is the 8-Bit ASCII representation of my name, "Yosef Roba Megersa"
following your specifications:

01011001 | 01101111 | 01110011 | 01100101 |

01100100 | 01100011 | - | 01010011 | 01110010 |
01100001 | 01100011 | - | 01001101 | 01100101 |
01100011 | 01110010 | 01100101 | 01110011 |
01100101 | 01110011 | 01100001

3)Programmability

The programmability of a computer can be significant in so many ways, here are

some that came into mind;
i. Versatility: A programmable computer isn't limited to performing a fixed set
of operations. Instead, it can be instructed to perform any task that can be broken
down into a sequence of steps. This means it can be adapted to solve problems in
various fields, from scientific research to financial analysis to creative endeavors.

ii. Automation: Programmability allows us to automate repetitive or complex

tasks. Instead of manually performing the same steps over and over, we can write
a program that does it for us, freeing up our time and energy for more creative or
strategic work.

4
 iii. Innovation: Programmability fuels innovation. By creating new programs,
we can explore new ideas, develop new solutions, and push the boundaries of
what computers can do.

iv. Adaptability: The world is constantly changing, and programmable

computers can adapt to those changes. We can update programs, add new
features, and modify their behavior to meet new needs and challenges.

➢ Here are two examples of Programmable Computers:

1. The ENIAC (Electronic Numerical Integrator and Computer):

Level of Programmability: The ENIAC was initially programmed by physically
rewiring its circuits. This was a laborious process, requiring days or even weeks to
modify the machine's behavior. However, it was still programmable, meaning it
could be instructed to perform different tasks.
Significance: The ENIAC was a groundbreaking machine, demonstrating the
potential of electronic computers for complex calculations. Its programmability,
though limited, paved the way for more flexible and user-friendly programming
methods.
2. The IBM PC (Personal Computer):
Level of Programmability: The IBM PC introduced a high level of programmability
through software. Users could write programs in various languages, such as BASIC,
C, and Assembly, allowing for a wide range of applications.
Significance: The IBM PC revolutionized personal computing, making computers
accessible to a wider audience. Its high level of programmability allowed users to
customize their machines, develop software, and create new applications, driving
the growth of the software industry.

5
4) Algorithms

An algorithm is like a recipe for solving a problem or completing a task. It's a well-
defined set of instructions that, when followed step-by-step, leads to a specific
outcome. Think of it as a blueprint for achieving a desired result.

Here's a more elaborately detailed explanation on algorithms as we go in depth:

• A Sequence of Steps: An algorithm is a series of clearly defined instructions,

each with a specific purpose. These instructions are arranged in a logical
order, ensuring that the algorithm progresses towards its intended goal.
• Well-Defined Instructions: Each step in an algorithm must be unambiguous
and precise. There should be no room for interpretation or ambiguity. This
ensures that anyone following the algorithm will arrive at the same result.
• Finite: An algorithm must have a finite number of steps. It shouldn't go on
indefinitely. Additionally, each step should be deterministic, meaning it
produces a predictable outcome based on the input.
• Input and Output: An algorithm typically takes some input, processes it
according to its instructions, and produces an output. The input can be
data, information, or even other algorithms. The output is the result of the
algorithm's execution.
• Problem-Solving Tool: Algorithms are fundamental to problem-solving.
They provide a systematic approach to tackling challenges, whether it's
finding the shortest route between two points, sorting a list of numbers, or
encrypting a message.

6
Examples of Algorithms:
Sorting Algorithms: These algorithms arrange items in a specific order, such as
alphabetically or numerically. Examples include bubble sort, insertion sort, and
quicksort.
Search Algorithms: These algorithms find specific items within a collection of data.
Examples include linear search and binary search.
Navigation Algorithms: These algorithms determine the shortest or most efficient
route between two locations. Examples include Dijkstra's algorithm and A* search.
Encryption Algorithms: These algorithms transform data into a secure format,
making it difficult for unauthorized individuals to access. Examples include RSA
and AES.

Importance of Algorithms:

Algorithms are the backbone of modern technology. They power everything from
search engines and social media platforms to self-driving cars and medical
diagnostics. They are essential for:
Computer Science: Algorithms are the foundation of computer programming and
software development.
Data Science: Algorithms are used to analyze data, extract insights, and make
predictions.
Artificial Intelligence: Algorithms are used to develop intelligent systems that can
learn, reason, and make decisions.

7
a . Let's consider the mathematical expression: (x + y) * z
Sentence-based Explanation:
Start: Begin by initializing three variables: 'x', 'y', and 'z' with their respective input
values.
Addition: Calculate the sum of 'x' and 'y' and store the result in a variable called
'sum'.
Multiplication: Multiply the value of 'sum' by 'z' and store the final result in a
variable called 'product'.
Return: Output the value of 'product' as the result of the expression.

b . Graphical diagrams
i. Flowchart:
graph LR
A[Start] --> B{Initialize x, y, z}
B --> C{sum = x + y}
C --> D{product = sum * z}
D --> E{Return product}
E --> F[End]
Explanation:
Rectangles: Represent actions or processes.
Diamonds: Represent decision points (if-else statements).
Arrows: Indicate the flow of control.
Start and End: Marked by rounded rectangles.

8
ii. Pseudocode:

def calculate_expression(x, y, z):

sum = x + y
product = sum * z
return product
Explanation:
Function Definition: def calculate_expression(x, y, z): defines a function named
"calculate_expression" that takes three integers 'x', 'y', and 'z' as input.
Addition: sum = x + y calculates the sum of 'x' and 'y'.
Multiplication: product = sum * z multiplies the sum by 'z'.
Return: return product returns the final result.

9
5) Bugs, Debugging and Errors
In the context of computer programming, a "bug" refers to an error, flaw, or defect
in the code that causes a program to behave unexpectedly or incorrectly. These
bugs can range from simple typos to complex logical errors, and they can have a
variety of consequences, from minor annoyances to major system crashes.
Debugging is the process of identifying, analyzing, and fixing these bugs. It's a
crucial part of software development, ensuring that programs function as
intended and meet the desired requirements. Here's a detailed explanation of
debugging, supported by examples:
i. Identifying Bugs:
Unexpected Output: The program produces incorrect results or outputs that differ
from the expected behavior. For example, a calculation program might give a
wrong answer due to a misplaced operator or a faulty mathematical formula.
Program Crashes: The program terminates abruptly or unexpectedly, often
displaying error messages. This could be caused by issues like accessing invalid
memory locations, dividing by zero, or encountering an infinite loop.
Unexpected Behavior: The program behaves in ways that were not intended, such
as displaying the wrong information, ignoring user input, or performing actions
out of sequence.
ii. Analyzing Bugs:
Reproducing the Bug: The first step is to reproduce the bug consistently. This
involves identifying the specific conditions under which the bug occurs, such as a
particular input, sequence of actions, or environment setup.
Tracing the Code: Once the bug is reproducible, the programmer needs to trace
the execution of the code step-by-step to pinpoint the source of the error. This can
be done by using debugging tools like breakpoints, stepping through the code line
by line, and inspecting the values of variables at different points.

10
Analyzing Error Messages: Error messages generated by the compiler or runtime
environment can provide valuable clues about the nature of the bug. These
messages often indicate the specific line of code where the error occurred and the
type of error (e.g., syntax error, runtime error).
iii. Fixing Bugs:
Correcting the Code: Once the bug is identified, the programmer needs to correct
the code to eliminate the error. This may involve fixing a typo, changing a logical
condition, adding missing code, or removing unnecessary code.
Testing the Fix: After making the correction, it's essential to thoroughly test the
code to ensure that the bug is fixed and that the program now behaves as
expected. This may involve running the program with various inputs, scenarios,
and edge cases to ensure that the fix does not introduce new bugs.

Examples of Debugging:
Example 1: Simple Typo

11
Example 2: Logical Error

Example 3: Runtime Error

12
a ) The analogy of "Needle in a haystack" is a fitting one for the debugging
process, highlighting the challenge of finding a tiny error within a vast
amount of code. Here's how I'd break down the analogy:
The Needle:
The bug itself: This is the actual source of the problem, the specific error or flaw in
the code. It's small, often hidden, and can be difficult to locate. Just like a needle,
it's a tiny element within a much larger system.
The specific line of code causing the issue: While the bug is the root cause, the
actual manifestation of the bug might be a single line of code that produces the
unexpected behavior. This line of code is like the needle, the precise point where
the error is triggered.
The Haystack:
The entire codebase: This represents the vast amount of code that makes up the
program. It's like a haystack, full of seemingly similar lines of code, making it
difficult to find the single needle that's causing the issue.
The context surrounding the bug: The bug doesn't exist in isolation. It's influenced
by the surrounding code, variables, and functions. This context can be confusing
and make it harder to isolate the bug, like trying to find a needle in a haystack
that's constantly shifting and changing.
Reasoning and Explanations:
The Needle's Size and Importance: The bug is small, often a single character or a
misplaced line of code, but its impact can be significant. It's like a tiny needle that
can cause a large haystack to unravel.
The Haystack's Complexity: The codebase can be massive, with thousands of lines
of code, making it difficult to search for a single bug. This complexity is like the
haystack's vastness, making it hard to find the needle.
The Search Process: Debugging involves carefully examining the code, testing
different scenarios, and tracing the flow of execution to isolate the bug. This

13
process is like searching through the haystack, meticulously examining each piece
to find the needle.

b ) In programming, errors are very common and hard to avoid. They can stem
from typos, logical flaws, or even interactions with the system. Understanding
the different types of errors is crucial for effective debugging and writing robust
code. Here are some common error types with illustrative examples:
1. Syntax Errors:
Definition: These errors occur when the code violates the grammatical rules of the
programming language. The compiler or interpreter cannot understand the code
and throws an error.
Example:
print("Hello, world!"
Error: SyntaxError: invalid syntax
Explanation: The missing closing parenthesis ) after the string violates the syntax
rules of Python.
2. Runtime Errors (Exceptions):
Definition: These errors occur during the execution of the program, usually due to
unexpected events or conditions that the program is not designed to handle.
Example:

Error: ZeroDivisionError: division by zero

Explanation: The code attempts to divide by zero, which is an invalid operation in
mathematics and causes a runtime error.

14
3. Logical Errors:
Definition: These errors occur when the code is syntactically correct but does not
produce the intended results. The program runs without crashing, but it does not
behave as expected due to flawed logic.
Example:

Explanation: The code checks if the number is odd (number % 2 == 1) to

determine if it's even. This logic is flawed and leads to incorrect results.
4. Semantic Errors:
Definition: These errors occur when the code is syntactically correct and runs
without crashing, but it does not achieve the intended meaning or purpose. The
program might be functioning but not in the way it should.
Example:

Explanation: The code adds the length and width instead of multiplying them,
resulting in an incorrect area calculation.

15
5. Resource Errors:
Definition: These errors occur when the program encounters problems accessing
or managing resources like files, databases, or network connections.
Example:

Error: FileNotFoundError: [Errno 2] No such file or directory: 'nonexistent_file.txt'

Explanation: The code attempts to open a file that doesn't exist, leading to a
resource error.
6. Data Type Errors:
Definition: These errors occur when the program tries to perform operations on
data of incompatible types.
Example:
name = "John"
age = 25
result = name + age # Trying to concatenate string and integer
Error: TypeError: can only concatenate str (not "int") to str
Explanation: The code attempts to concatenate a string with an integer, which is
not allowed in Python.
7. Memory Errors:
Definition: These errors occur when the program runs out of available memory to
store data or execute instructions.

16
Example:

Error: RecursionError: maximum recursion depth exceeded

Explanation: The recursive function factorial exceeds the set recursion limit,
leading to a memory error.
These are some of the most common error types in programming. Understanding
these errors and their causes is essential for writing reliable and efficient code.

c ) 1. Syntax Error , because of the unclosed parentheses.

2. Runtime Error

17
REFERENCES

✓ GitHub: github.org
✓ GeeksforGeeks: geeksforgeeks.org; source for images.
✓ Scribd: www.scribd.com
✓ Udemy: udemy.com
✓ The Rust Programming Language Forum
✓ AAU course materials

18