Notes, summaries, assignments, exams, and problems for Computers

Early Binding

Early binding — the binding that can be resolved at compile time by the compiler is known as static or early binding. The method definition and the method call are linked during compile time. This happens when all information needed to call a method is available at compile time. Early binding is more efficient than late binding.

Late Binding

Late binding — it is a runtime process. The method definition and the method call are linked during runtime. Execution speed is lower in late binding. Overriding methods are bound using late binding.

Programming Paradigms

Below are common programming paradigms and their characteristics.

Object-Oriented Programming (OOP)

Object-oriented programming is a programming paradigm based on the concept... Continue reading "Early vs Late Binding and Major Programming Paradigms" »

Knapsack Problem: Recursive Approach

The following code demonstrates a naive recursive implementation of the 0-1 Knapsack problem in C++.

/* A Naive recursive implementation of 0-1 Knapsack problem */
#include <bits/stdc++.h>
using namespace std;

// A utility function that returns the maximum of two integers
int max(int a, int b) { return (a > b) ? a : b; }

// Returns the maximum value that can be put in a knapsack of capacity W
int knapSack(int W, int wt[], int val[], int n)
{
    // Base Case
    if (n == 0 || W == 0)
        return 0;

    // If weight of the nth item is more than Knapsack capacity W,
    // then this item cannot be included in the optimal solution
    if (wt[n - 1] > W)
        return knapSack(W, wt, val, n

Strategic Approach: Begins with technical reviews to identify errors early. Moves from component-level (unit testing) to system-level integration. Different strategies suit conventional software, object-oriented software, and web applications.

Strategies for Different Systems

• Conventional Software: Focus on module testing and integration.
• Object-Oriented Software: Emphasis shifts to classes, attributes, and their collaborations.
• Web Applications: Covers usability, interface, security, and environmental compatibility.

Key Strategic Issues: Define requirements quantitatively before testing. Develop robust software with self-testing capabilities. Use iterative testing cycles to refine quality. Employ independent testers alongside developers.

Regression

Unit I — Computer Fundamentals

1. Generations of Computers

Computers have evolved significantly over time, categorized into generations based on technological advancement. The first generation (1940–1956) relied on vacuum tubes, which made computers bulky, expensive, and heat-prone. These machines used machine language and had limited speed, processing only basic calculations. The second generation (1956–1963) replaced vacuum tubes with transistors, reducing size, cost, and power consumption. Assembly language became popular during this era, making programming easier. The third generation (1964–1971) introduced integrated circuits (ICs), improving reliability and processing speed while reducing physical size. High-level programming languages... Continue reading "Fundamentals of Computers: Generations, Memory & Networks" »

Understanding Operating System Memory and File Structures

Virtual Memory Concepts

Virtual memory is a fundamental concept in modern operating systems, offering several key advantages:

1. There are many cases where an entire program is not needed in main memory at a given time.
2. Even when the entire program is needed, it may not all be required simultaneously.
3. Application programs always perceive the availability of a contiguous working address space due to the concept of virtual memory.
4. Actually, this working memory can be physically fragmented and may even overflow onto disk storage.
5. This technique makes programming of large applications easier and utilizes real physical memory more efficiently than systems without virtual memory.
6. Although an executing

ARM Family Core Architecture and Design Philosophy

ARM (Advanced RISC Machine) is a family of 32-bit/64-bit RISC processors designed for high performance, low power consumption, and efficient execution. ARM processors are widely used in embedded systems, smartphones, and IoT devices.

Components of the ARM Core Architecture

• ARM Core: Executes instructions and performs arithmetic and logical operations. It contains registers, an ALU, and a control unit.
• Instruction Cache: Stores frequently used instructions. It improves execution speed by reducing memory access time.
• Data Memory / Data Cache: Stores program data and temporary variables, enabling faster data access.
• Bus Interface: Connects the processor with memory and peripherals, transferring data

Common Bus System Explained

The common bus system is an architecture where a single bus is used for communication between various components of a computer, such as memory, registers, and the ALU. This system minimizes the number of pathways required, thereby simplifying the design and saving space.

Components of a Common Bus System:

• Set of Registers (R1, R2, ...)
• Arithmetic Logic Unit (ALU)
• Control Unit
• Common Bus
• Memory Unit

Operation of a Common Bus System:

• Only one register can place its contents on the bus at a time.
• A control unit uses selection lines and control signals to manage data transfers.
• A multiplexer selects which register’s data will go onto the bus.
• A decoder selects the destination register to receive the data.

Advantages:

• Reduces hardware

Sign-Up Form

Name:Date of Birth:

Sign Up

Introduction to Tuples

• Immutable: Cannot be changed after creation.
• Syntax: Defined using parentheses ().
• Versatile: Can store multiple data types.
• Performance: Faster than lists due to immutability.

Common Use Cases for Tuples

• Returning multiple values: Functions can return multiple values as a tuple.
• Representing records: Ideal for structured data like names, ages, and addresses.
• Dictionary keys: Tuples can be used as keys in dictionaries.

Basic Tuple Operations

Length

Returns the number of elements in the tuple.
Example: len((1, 2, 3)) Output: 3

Repetition

Repeats the tuple a specified number of times.
Example: (1, 2) * 3 Output: (1, 2, 1, 2, 1, 2)

Iteration

Loop through elements of a tuple.
Example: for x in (1, 2, 3): print(x) Output: 1, 2, 3

Comparison

Functional Units of a Computer

A computer system is logically divided into several functional units that work together to perform data processing. These units accept input, process the data, store information, and produce output.

Main Functional Units

1. Input Unit

• Accepts raw data and instructions from the user and enters them into the computer.
• Converts the input data into machine-readable form (binary) for processing.

Examples: Keyboard, Mouse, Scanner, Microphone.

2. Output Unit

• Displays the processed results to the user.
• Converts the machine results into human-readable form.

Examples: Monitor, Printer, Speakers.

3. Memory Unit

• Stores data, instructions, and intermediate results required for processing.
• Supplies data to the CPU whenever needed.

Types