CSC 218 GENERAL NOTES
High-level (H/L) programming languages, like Python, Java, or C++, are designed for human readability
and ease of programming, but they need to be translated into machine-understandable instructions to be
executed by a computer. This translation process involves several key aspects of computer architecture
and language implementation.
1. Basic Machine Architecture:
Basic computer architecture encompasses the fundamental components and their interconnections that
define how a computer operates. Key elements include the CPU (Central Processing Unit), memory (RAM
and storage), input/output devices, and the bus system that connects them. The CPU, often referred to
as the "brain," executes instructions and performs calculations. Memory stores both data and
instructions, while input/output devices allow for interaction with the user and external systems. These
components work together to process information and enable a computer to function.
Key Components:
• CPU (Central Processing Unit):
The core component responsible for executing instructions and performing calculations. It consists of
the Arithmetic Logic Unit (ALU) for operations and the Control Unit for managing the flow of
instructions.
• Memory:
• RAM (Random Access Memory): Temporary storage for data and instructions that the
CPU is actively using. It's volatile, meaning data is lost when the power is turned off.
• Storage (e.g., Hard Drives, SSDs): Permanent storage for data and programs, even when
the computer is off.
• Input/Output (I/O) Devices:
Allow users to interact with the computer (e.g., keyboard, mouse, monitor, printer) and other systems.
• Bus System:
A collection of pathways that enable communication between different components of the
computer. Buses include:
• Address Bus: Specifies the memory location being accessed.
• Data Bus: Transmits data between components.
• Control Bus: Sends control signals to manage operations.
How it Works:
1. Instruction Fetch: The CPU fetches an instruction from memory.
2. Instruction Decode: The Control Unit interprets the instruction.
3. Operand Fetch: If the instruction requires data, it's fetched from memory.
4. Execution: The ALU performs the operation specified by the instruction.
5. Result Storage: The result of the operation is stored in memory or a register.
6. Repeat: The process repeats for the next instruction.
Beyond the Basics:
• Cache:
A small, fast memory that stores frequently used data, improving performance by reducing the need to
access slower main memory.
• Operating System:
Software that manages the computer's resources and provides a user interface.
• Parallel Computing:
Utilizing multiple processors or cores to perform computations simultaneously, enhancing performance.
• System Design:
The overall organization and structure of the computer system, including the selection and arrangement
of components.
2. Assemblers and Translation
Assemblers are software tools that translate assembly language code into machine code, which is directly
executable by a computer's processor. Assembly language is a low-level programming language that uses
symbolic representations (mnemonics) for machine instructions, making it more readable than raw
machine code. The assembler essentially performs a one-to-one mapping between assembly instructions
and their corresponding machine code representations.
Here's a more detailed breakdown:
1. Assembly Language:
• Assembly language is a human-readable representation of machine code.
• It uses mnemonics (short, symbolic codes) to represent operations, registers, and memory
locations.
• For example, "ADD AX, BX" might mean "add the contents of register BX to register AX".
2. Assembler:
• An assembler takes assembly language code as input and produces machine code as output.
• It performs a direct translation, where each assembly instruction usually has a corresponding
machine code equivalent.
• Assemblers are specific to a particular processor architecture (e.g., x86, ARM).
3. Translation Process
In the context of programming, the translation process refers to converting source code written in a high-
level language (like Python or Java) into a lower-level language (like machine code) that a computer can
directly execute. This process is typically handled by translators, which can be either compilers or
interpreters.
Here's a more detailed breakdown:
1. Source Code: This is the code written by the programmer in a high-level language.
2. Translation: The translation process involves several stages:
• Lexical Analysis: The source code is broken down into individual components (tokens) like
keywords, identifiers, and operators.
• Syntax Analysis: The tokens are checked for grammatical correctness according to the rules of
the language.
• Semantic Analysis: The meaning of the code is checked to ensure it makes sense.
• Intermediate Code Generation: The code is converted into an intermediate form that is easier
for the translator to work with.
• Code Optimization: The intermediate code is optimized for better performance.
• Code Generation: The optimized intermediate code is translated into the target language (e.g.,
machine code).
3. Target Code (Machine Code): This is the low-level code that the computer's processor can directly
understand and execute.
Types of Translators:
• Compilers:
Translate the entire source code into machine code at once and then execute it. They report all errors
after the entire code has been processed.
• Interpreters:
Translate and execute the code line by line. They report errors as they encounter them.
In essence, the translation process ensures that the instructions written by the programmer are
converted into a format that the computer can understand and run.
3. 1 Translation Process in Assembler
• The assembler reads the assembly code line by line.
• It looks up each mnemonic in a predefined table that maps mnemonics to their corresponding
machine code opcodes and operand formats.
• The assembler then constructs the machine code instruction, combining the opcode and
operands.
• This process may involve other steps like resolving symbolic addresses (labels) and creating data
tables.
4. Example:
Let's say you have an assembly instruction: ADD AX, BX.
• The assembler would look up the mnemonic "ADD" in its table, which might be associated with
a machine code opcode like 0x01.
• It would also identify that AX and BX are registers and their corresponding binary
representations.
• The assembler might then construct a machine code instruction like 0x01 0x01
0x02 (assuming AX is register 1 and BX is register 2).
5. Importance of Assemblers:
• Direct Hardware Access:
Assembly language and assemblers are essential for tasks requiring direct control over hardware
resources, such as device drivers, embedded systems, and performance-critical sections of code.
• Low-Level Programming:
They allow programmers to work at a lower level of abstraction than high-level languages, giving them
more control over how the code interacts with the hardware.
• Performance Optimization:
In some cases, assembly language can be used to optimize performance-critical parts of a program, as it
provides fine-grained control over the execution process.
6. Comparison with Compilers and Interpreters:
• Compilers: Translate high-level language code (like C++, Java) into machine code in one go.
• Interpreters: Translate and execute high-level language code line by line.
• Assemblers: Translate assembly language (which is already very close to machine code) into
machine code.
4. Block-Structured Languages
Block-structured languages in programming are those that organize code into blocks, which are segments
of code that are treated as a single unit, often delimited by keywords like begin and end or curly
braces {}. These blocks can contain other blocks, creating a hierarchical structure. This structure allows for
better organization, readability, and management of code, especially in larger programs.
• Scope and Blocks:
Block-structured languages like C, Pascal, and Algol define code in blocks (e.g., within functions or loops)
with specific scopes. Variables declared within a block are only accessible within that block.
• Stack Frames:
Compilers for block-structured languages use a stack to manage function calls and local variables. When
a function is called, a stack frame is created to store the function's local variables and the return
address. When the function returns, the stack frame is removed.
Here's a more detailed explanation:
Key Characteristics:
• Blocks:
Code is divided into blocks, which are sequences of statements enclosed within delimiters.
• Nesting:
Blocks can be nested within other blocks, creating a hierarchical structure.
• Scope:
Variables declared within a block are typically only accessible within that block (and its nested blocks),
defining their scope.
• Delimiters:
Languages use different delimiters to define blocks. Examples include begin/end (e.g., in ALGOL, PL/I,
Pascal), and {} (e.g., in C, C++, Java, C#). Python uses indentation as a delimiter, according to the University
of Miami.
• Examples:
Popular block-structured languages include ALGOL, Pascal, C, C++, Java, C#, and PL/I.
Benefits of Block Structure:
• Improved Code Organization:
Block structure makes code easier to read and understand by visually grouping related statements.
• Modularity:
Blocks can be treated as modules, making it easier to break down complex problems into smaller,
manageable parts.
• Control over Scope:
Scope rules enforced by block structure help prevent naming conflicts and unintended side effects.
• Reduced Complexity:
By nesting blocks, you can create complex logic in a structured and organized way.
Historical Context:
• The ALGOL family of languages is credited with popularizing the concept of block structure.
• Languages like Pascal and its derivatives adopted and extended block structuring.
• C and its successors incorporated block structure using curly braces.
5. Parameter Passing Mechanisms
Parameter passing mechanisms determine how values are exchanged between a function call and the
function being called. The two primary methods are call by value and call by reference, with call by pointer
being a variation often used in C/C++. Call by value creates copies of the arguments, while call by reference
provides the function with direct access to the memory location of the arguments, allowing modifications
to affect the original values.
Call by Value:
In this mechanism, the value of the argument is copied to the parameter. Any changes to the parameter
within the function do not affect the original argument.
• A copy of the argument's value is passed to the function.
• Changes made to the parameter inside the function do not affect the original argument in the
calling function.
• This is the default behavior in many languages like Java and C.
Call by Reference:
In this mechanism, the parameter refers to the same memory location as the argument. Changes to the
parameter within the function will affect the original argument.
• The memory address (reference) of the argument is passed to the function.
• The function can directly access and modify the original argument's value.
• Changes made inside the function are reflected in the calling function.
• Often achieved using pointers in C/C++ or by using the & symbol in the function declaration in
languages like Pascal and C++.
Call by Pointer (C/C++):
Provides the flexibility of call by reference, but requires careful handling of pointers to avoid errors.
• Similar to call by reference, but explicitly uses pointers to pass the memory address of the
argument.
• The function receives a pointer to the argument and can dereference the pointer to modify the
original value.
Example (Conceptual):
C++
// Call by value (simplified)
void incrementByValue(int x) { // x is a copy
x = x + 1;
}
int main() {
int num = 5;
incrementByValue(num); // num is passed by value
// num will still be 5 in main after the function call because a copy was modified
}
// Call by reference (simplified)
void incrementByReference(int &x) { // x is a reference
x = x + 1;
}
int main() {
int num = 5;
incrementByReference(num); // num is passed by reference
// num will be 6 in main after the function call because the original was modified
}
Choosing the right mechanism
• Call by value:
Suitable when modifications to the parameter within the function should not affect the original value. It
provides a level of safety and isolation.
• Call by reference:
Appropriate when the function needs to modify the original argument. It can also be more efficient for
large data structures as it avoids copying the entire data.
• Call by pointer:
Provides the flexibility of call by reference, but requires careful handling of pointers to avoid errors.
• Compilers and Parameter Passing:
Compilers implement these parameter passing mechanisms by generating appropriate machine
instructions to copy values or pass memory addresses.
6. Relationship
H/L languages provide high-level abstractions, while computer architecture provides the underlying
hardware to execute those abstractions. The compiler acts as a translator, bridging the gap between the
high-level code and the low-level machine instructions. It utilizes the computer's architecture (registers,
memory, instructions) to represent and manipulate data and execute the program's logic.
In essence, the computer architecture provides the foundation, while the compiler acts as the translator
and manager of the H/L language, making it possible to run complex programs efficiently on a given
hardware platform.
