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

Core Concepts in Compiler Design

Compiler

Compiler: Translates entire source code to target code before execution. It requires a full parse and upfront error checking, then executes the generated target code.

Interpreter

Interpreter: Executes source code incrementally (line-by-line or statement-by-statement). It translates and executes on the fly, and may partially execute ill-formed programs until an error is encountered.

LVar vs. x86 Architecture

LVar: Features nested expressions, implicit control flow (represented by an Abstract Syntax Tree - AST), and an unlimited number of logical variables.

x86: Characterized by flat instructions, atomic operands (registers/memory), explicit control flow (jumps), and a limited set of registers. Compilation passes... Continue reading "Core Concepts in Compiler Design and Language Runtime" »

Introduction to OOP Concepts

This document presents practical code examples demonstrating fundamental Object-Oriented Programming (OOP) concepts in both Delphi (Pascal) and C++. It covers class definitions, object instantiation, properties, events, static members, inheritance, polymorphism, memory management, and exception handling.

Delphi Object-Oriented Programming

The following Delphi code illustrates the creation of classes, properties, events, and static members, along with their usage in a console application.

program Cheat;
{$APPTYPE CONSOLE}

uses
  SysUtils, Classes;

type
  TNotify = procedure(Sender: TObject) of object;

  TEngine = class
    procedure Start;
    begin
      Writeln('Engine Started');
    end;
  end;

  TCar = class

C Linked List Implementations for Student Data

This document presents two distinct C language implementations for managing student records using linked lists: a singly linked list and a circular linked list. Both examples demonstrate fundamental data structure operations such as adding, deleting, searching, and displaying student information.

1. Singly Linked List Implementation

This section details a student management system built using a singly linked list. Students are stored in ascending order of their roll numbers, and duplicate roll numbers are prevented.

Core Structure and Global Head

The Student structure defines the data for each node, including roll number, total marks, average, and a pointer to the next student. The head pointer always... Continue reading "C Linked List Student Data Management Systems" »

Journaling Motivation and Necessity

File System Check (FSck) ensures metadata consistency after crashes but is slow and requires deep file system knowledge. Recovery time should ideally depend on the number of recent writes.

File System Transactions and ACID Properties

Transactions provide ACID guarantees:

• Atomicity
• Consistency
• Isolation
• Durability

These are used to treat file system operations (like file creation) as transactions. Recovery ensures committed transactions are applied and uncommitted ones are discarded.

ext3 Journaling File System

ext3 is a journaling file system using physical redo logging, adding journaling to existing ext2 structures.

Redo Logging Mechanism in ext3

The process involves writing updates to a journal first, then committing... Continue reading "File System Journaling: Mechanisms, ext3, and NTFS Recovery" »

Expressions and Operators Fundamentals

Expressions Defined

What constitutes a valid expression in programming?

Understanding Operators

Operator Definition and Types

An operator is a symbol that represents a computation. What are the three primary types of operators?

• Unary: Operates on one operand (e.g., -x).
• Binary: Operates on two operands (e.g., x + y).
• Ternary: Operates on three operands (e.g., (a > b) ? a : b).

Order of Operation and Precedence

How is the order of operation determined? What mechanisms can be used to change the default order of operation?

Order is typically governed by Operator Precedence Rules and Associativity Rules (e.g., left-to-right). Parentheses can be used to override the default order.

Conditional Expressions

What is a conditional... Continue reading "Programming Language Concepts: Expressions, Control Flow, and Subprograms" »

Digital Logic Circuits

Flip-Flops

Clocked RS Flip-Flop Drawbacks

Clocked RS flip-flops have some drawbacks, such as susceptibility to race conditions, where the output can become unpredictable if the inputs change too close to the clock edge. They also require careful handling of the inputs to avoid metastability issues, which can lead to incorrect output states. Additionally, they can have higher power consumption compared to other flip-flop types due to the need for a clock signal.

JK Flip-Flop Operation

Content about JK Flip-Flop operation, characteristic table, characteristics equation, circuit diagram, and timing diagram would be added here.

Magnitude Comparator

What is a Magnitude Comparator?

A magnitude comparator is a digital circuit that compares... Continue reading "Digital Logic Circuits: Flip-Flops, Comparators, Decoders, and Registers" »

ABAP Fundamentals: Key Concepts and Technical Q&A

Review essential knowledge points covering ABAP syntax, data structures, system fields, and event processing.

1. Client Dependency in ABAP Dictionary Tables

   If a table does not have MANDT as part of the primary key, it is:

   Client-independent

2. Invalid ABAP CALL Statement

   In regard to CALL, which of the following is NOT a valid statement?

   CALL PROGRAM

3. Characteristics of Transparent Tables

   Name the type of ABAP Dictionary table that has these characteristics:

   • Same number of fields as the database table
   • Same name as the database table
   • Maps 1:1 to the database table

   Transparent Table

4. ABAP Event Structure

   An event starts with an event keyword and ends with:

   Another event keyword

5. System Field for Current Date

   What is

Lecture 2: Dynamic Dispatch and Interfaces

• Dynamic Dispatch: The process of selecting which implementation of a polymorphic operation to call at runtime.
• Interface: Calling a method that is not in the interface will cause a compilation error.

Lecture 3: N/A

Lecture 4: Method Contracts, Exceptions, and Unit Testing

• Method Contract: Should define pre/post conditions and exceptional behavior. The client is to blame if the precondition is not met, and the service is to blame if the postcondition is not met. Exceptional behavior specifies what the code will do if a precondition is violated.
• Exception: Runtime exception (unchecked) and IO exception (checked). The IO exception must be caught; otherwise, the code won't compile.
• Unit Test: Test boundary

What is a Neural Network?

A Neural Network is a component of Artificial Intelligence (AI) that mimics how the human brain works. It is used to process information, recognize patterns, and make decisions, similar to human cognition.

Core Structure and Function

• Neural networks are computer systems modeled on the structure of the human brain. They consist of layers of nodes (neurons).

Layers of a Neural Network

• Input Layer: Takes the input data.
• Hidden Layers: Process the data using mathematical operations.
• Output Layer: Gives the final result.

How Neural Networks Learn

Neural networks learn by identifying patterns in data through training.

How a Neural Network Works (Step-by-Step)

1. Input: Data is given to the network through the input layer.
2. Processing: Hidden

C++ Priority Queue Implementation

This document provides a C++ implementation of a priority queue using a heap data structure. The code includes the class definition, member functions, and supporting utilities.

Priority Queue Class Definition

#ifndef priority_queue_h_
#define priority_queue_h_

#include <iostream>
#include <vector>
#include <cassert>

template <class T>
class priority_queue {
private:
    std::vector<T> m_heap;

public:
    priority_queue() {}

    priority_queue(std::vector<T> const& values)
    {
        m_heap = values;
        for (int i = 0; i < m_heap.size(); i++){
            percolate_down(i);
            for (int j = i; j < m_heap.size(); j++){
                percolate_down(