KembaraXtra - Computer Science - Math in High-Level Languages

1. Common Math Operators

• High-level languages use symbols for math operations, similar across languages like C and Python.

2. Assignment vs. Equality

• The equals sign = typically represents assignment (setting a variable's value), not equality (comparison).
• x = 5 means "set the value of x to 5."

3. Integer Math vs. Floating-Point Arithmetic

• Integers: Whole numbers (no fractions).
• Floating-Point: Numbers that can represent fractions.

4. Type Declaration

• C: Requires explicit type declaration for variables.
• int x = 5; // Declares an integer variable x
• double price = 1.99; // Declares a floating-point variable price
• Python: Infers type automatically.
• year = 2020 # year is an int
• price = 1.99 # price is a float

5. Integer Division

• C: Dividing integers results in an integer (fractional part is truncated).
• int x = 5; int y = 2; int z = x / y; // z will be 2
• If the result is assigned to a float, the integer result is converted to a float, but the fractional part is already lost.
• int x = 5; int y = 2; float z = x / y; // z will be 2.0
• Python: Dividing integers results in a float (fractional part is preserved).
• x = 5; y = 2; z = x / y # z will be 2.5

6. Abbreviated Math Operators

• Increment/Decrement (C):
• x++; // Increment x (add 1)
• x--; // Decrement x (subtract 1)
• Add and Assign / Subtract and Assign (C and Python):
• cats += 3 // Equivalent to cats = cats + 3
• cats -= 3 // Equivalent to cats = cats - 3

KembaraXtra - Computer Science - Stack and Heap Memory

I. Introduction

• High-level languages abstract memory management, with varying degrees of transparency (e.g., Python vs. C).
• Programs utilize two main types of memory: stack and heap.

II. The Stack

• Definition: An area of memory that operates on a Last-In, First-Out (LIFO) model.
• Analogy: Stack of plates.
• LIFO Operation:
• Last item added is the first item removed.
• Items can be read or modified at any time while on the stack.
• Stack Pointer:
• A processor register stores the memory address of the top of the stack.
• The stack pointer adjusts to make room for a value on the stack.
• The stack pointer adjusts to decrease the size of the stack when a value is removed.
• Usage:
• The compiler uses the stack to track the state of program execution and store local variables.
• Implementation details are usually hidden from the programmer.
• Memory Allocation (C Example):
• Variables are pushed onto the stack as they are declared.
• The order of declaration determines their position on the stack.
• Memory addresses on the stack decrease as the stack grows (in many architectures).
• Characteristics:
• Fast and efficient for small, temporary data.
• Each thread of execution has its own stack.
• Limited resource; prone to stack overflow if too much data is pushed onto it.

III. The Heap

• Definition: A pool of memory available to a program.
• Allocation Model:
• Unlike the stack, the heap doesn't have a LIFO model.
• No standard allocation model.
• Accessibility:
• Heap allocations can be accessed by any of the program's threads.
• Memory Management:
• Memory is allocated from the heap and persists until explicitly freed or the program terminates.
• Freeing Memory: Releasing memory back to the available pool.
• Garbage Collection: Automatic memory freeing when an allocation is no longer referenced (common in some languages).
• Memory Leaks: Occur when unused memory is not freed.
• Pointers (C Language):
• Pointers are variables that hold memory addresses.
• Used to track heap memory allocations.
• The pointer itself can be a local variable stored on the stack, pointing to an address in the heap.
• Heap Allocation in C (Example):
• malloc() function allocates memory from the heap and returns the address of the allocated block.
• The pointer to this memory (returned by malloc()) is typically stored in a local variable on the stack.

IV. Stack vs. Heap: Key Differences

V. Key Terminology

• Stack: LIFO memory area for local variables and program state.
• Heap: Memory pool for dynamic allocation of larger, persistent data.
• LIFO: Last-In, First-Out.
• Stack Pointer: Register tracking the top of the stack.
• Stack Overflow: Error when the stack runs out of memory.
• Garbage Collection: Automatic memory management.
• Memory Leak: Unused memory that is not freed.
• Pointer: A variable holding a memory address.

VI. Important Considerations

• Choose stack for small, short-lived data within a limited scope.
• Choose heap for larger data or data that needs to persist longer and be accessible across different parts of the program.
• Be aware of memory management responsibilities in languages like C to avoid memory leaks.

KembaraXtra – Computer Science – Web Servers

I. Client-Side vs. Server-Side Technologies

• Client-Side: Primarily deals with what the user sees and interacts with in the web browser. Uses HTML, CSS, and JavaScript.
• Server-Side: Deals with the logic and data processing behind the website. Any programming language or technology can be used, as long as it communicates over HTTP and returns data in a format the client understands.

II. Static vs. Dynamic Websites

Important Note: The terms "static" and "dynamic" refer to how the content is generated on the server, not whether the website is interactive or has updated content. User experience (interactivity, content updates) is often handled with JavaScript on the client-side, regardless of whether the site is static or dynamic from the server's perspective.

III. How Static Websites Handle Requests

1. Browser requests a specific URL.
2. Web server receives the request.
3. Web server finds the corresponding static file (e.g., /images/cat.jpg) in its directory.
4. Web server returns the content of that file to the browser.
5. The server does not modify the content.

IV. How Dynamic Websites Handle Requests

1. Browser requests a specific URL.
2. Web server receives the request and determines that it needs to generate HTML.
3. The server executes code.
4. The code queries a database and retrieves the relevant data.
5. The server formats the data as HTML.
6. The server responds to the client with the generated HTML.

V. The Trend Toward Static Sites

• In recent years, there has been a shift back towards static sites where possible.
• Static sites offer simplicity, speed, and security benefits.

VI. Hosting Static Sites

• You need a web server software that can serve static files.
• The software is configured to point to a directory containing the website files.
• When a request comes in, the server returns the contents of the matching file.

VII. Building Dynamic Websites/Web Services

• You can use existing software or write custom code to generate dynamic pages.
• Server-side development offers a wide range of technology choices (programming languages, operating systems, databases, etc.).
• The client doesn't care what technologies are used on the server-side; it only needs a response in a format it can handle.

VIII. Server-Side Technology Choices

• Programming Languages: Python, C#, JavaScript (Node.js), Java, Ruby, PHP, etc.
• Databases: Any type of database can be used.