Language-Level View of Primitives (Bridge Module)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#include <iostream>
#include <cstdint>  // For fixed-width types
#include <climits>  // For type limits
 
int main() {
    // Signed types (default for int, short, long)
    int signed_val = -42;
    
    // Unsigned types - double the positive range
    unsigned int unsigned_val = 4294967295;  // Max for 32-bit
    
    // Explicit width types (preferred for portable code)
    int32_t  precise_32 = -2147483648;   // Exactly 32 bits, signed
    uint64_t precise_64 = 18446744073709551615ULL;  // Exactly 64 bits, unsigned
    
    // Character types
    char c = 'A';              // 8-bit, signedness is platform-dependent!
    signed char sc = -1;       // Explicitly signed
    unsigned char uc = 255;    // Explicitly unsigned
    
    // Size inspection
    std::cout << "sizeof(int): " << sizeof(int) << " bytes
";
    std::cout << "sizeof(double): " << sizeof(double) << " bytes
";
    std::cout << "INT_MAX: " << INT_MAX << "
";
    
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

#include <iostream>
 
struct Point {
    double x;   // 8 bytes
    double y;   // 8 bytes
};              // Total: 16 bytes, no hidden overhead
 
struct Mixed {
    char flag;    // 1 byte
    // 3 bytes padding (for alignment)
    int value;    // 4 bytes  
    double data;  // 8 bytes
};                // Total: 16 bytes (with alignment padding)
 
int main() {
    int arr[1000];  // Exactly 4000 bytes, contiguous
    
    // Memory addresses are predictable
    std::cout << "arr[0] address: " << &arr[0] << "
";
    std::cout << "arr[1] address: " << &arr[1] << "
";
    // arr[1] is exactly 4 bytes after arr[0]
    
    Point points[100];  // Exactly 1600 bytes, contiguous
    
    std::cout << "sizeof(Point): " << sizeof(Point) << "
";
    std::cout << "sizeof(Mixed): " << sizeof(Mixed) << "
";
    
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

public class PrimitivesVsObjects {
    public static void main(String[] args) {
        // Primitives - stored on stack, no object overhead
        int primitiveInt = 42;
        double primitiveDbl = 3.14159;
        boolean primitiveBool = true;
        
        // Wrapper objects - stored on heap, full object overhead
        Integer wrapperInt = Integer.valueOf(42);
        Double wrapperDbl = Double.valueOf(3.14159);
        Boolean wrapperBool = Boolean.TRUE;
        
        // Autoboxing: automatic conversion (convenient but has cost)
        Integer autoboxed = 42;  // Compiler converts to Integer.valueOf(42)
        int unboxed = autoboxed; // Compiler converts to autoboxed.intValue()
        
        // The null distinction: only objects can be null
        Integer nullableInt = null;  // Valid
        // int primitiveNull = null;  // Compile error!
        
        // Collections require objects (pre-generics restriction)
        java.util.List<Integer> intList = new java.util.ArrayList<>();
        intList.add(10);  // Autoboxed to Integer
        
        // Memory comparison
        System.out.println("int size: 4 bytes (stack)");
        System.out.println("Integer size: ~16 bytes (heap + object header)");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

public class CharacterHandling {
    public static void main(String[] args) {
        // Basic ASCII characters work as expected
        char letter = 'A';
        char digit = '9';
        
        // Unicode characters (BMP - Basic Multilingual Plane)
        char greekLetter = 'Ω';   // U+03A9
        char japaneseChar = '日';  // U+65E5
        
        // Supplementary characters (beyond 16 bits) require surrogate pairs
        String emoji = "😀";  // U+1F600
        System.out.println("Emoji length: " + emoji.length()); // Prints 2!
        
        // Correct way to handle: code points, not characters
        int codePoint = emoji.codePointAt(0);  // 128512 (0x1F600)
        System.out.println("Code point: " + codePoint);
        
        // Iterating over code points
        String mixed = "Hello 日本 😀";
        mixed.codePoints().forEach(cp -> 
            System.out.println(Character.toString(cp) + " -> U+" + 
                               Integer.toHexString(cp).toUpperCase())
        );
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

import sys
 
# Integers: arbitrary precision, but always objects
small_int = 42
big_int = 10 ** 100  # A googol - no overflow!
 
# Everything is an object
print(type(small_int))  # <class 'int'>
print((42).bit_length())  # Method on an integer: 6
 
# Even literals have methods!
print((255).to_bytes(2, 'big'))  # b'\x00\xff'
 
# Object size includes header overhead
print(f"Size of int 0: {sys.getsizeof(0)} bytes")      # 24 bytes
print(f"Size of int 42: {sys.getsizeof(42)} bytes")    # 28 bytes
print(f"Size of int 2**100: {sys.getsizeof(2**100)} bytes")  # ~44 bytes
 
# Boolean is a subclass of int
print(isinstance(True, int))  # True
print(True + True)  # 2
print(True * 10)    # 10
 
# Float is a 64-bit double wrapped as object
pi = 3.14159265358979
print(f"Float size: {sys.getsizeof(pi)} bytes")  # 24 bytes
 
# No distinction between "primitive" and "reference"
# Assignment always creates a reference
a = 42
b = a  # b references the same int object as a
print(a is b)  # True (same object for small ints due to interning)
 
# But immutability prevents mutation issues
b = 100  # Creates new int object, doesn't mutate
print(a)  # Still 42

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# Small integers are interned (pre-created and reused)
a = 256
b = 256
print(a is b)  # True - same object (interned)
 
# Large integers are NOT interned
x = 257
y = 257
print(x is y)  # False in interactive mode, may be True in scripts!
 
# This is why you should ALWAYS use == for value comparison
# Use 'is' only for identity (e.g., 'is None')
 
# Demonstration of immutability
def add_one(n):
    n = n + 1  # Creates new int object
    return n
 
value = 10
result = add_one(value)
print(value)   # Still 10 - immutable!
print(result)  # 11

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

import numpy as np
import sys
 
# NumPy provides fixed-width types like C
np_int32 = np.int32(42)
np_int64 = np.int64(42)
np_float64 = np.float64(3.14159)
 
# Much smaller memory footprint
print(f"Python int size: {sys.getsizeof(42)} bytes")  # ~28 bytes
print(f"NumPy int32 size: {np_int32.nbytes} bytes")   # 4 bytes
 
# Arrays of NumPy types are contiguous and cache-friendly
py_list = list(range(1000))       # ~36 KB (objects + references)
np_array = np.arange(1000, dtype=np.int64)  # 8 KB (contiguous)
 
# Vectorized operations are orders of magnitude faster
# Python loop: slow due to object overhead
# NumPy operation: fast due to C implementation
 
# Type-specific behavior (includes overflow!)
max_int8 = np.int8(127)
print(max_int8 + np.int8(1))  # -128 (wraps like C!)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

// Number: 64-bit double (includes integers, floats, special values)
const int = 42;          // Stored as 42.0 internally
const float = 3.14159;
const infinity = Infinity;
const notANumber = NaN;
 
// The integer precision limit
console.log(9007199254740993 === 9007199254740992);  // true! Precision lost
 
// BigInt: arbitrary precision integers (ES2020+)
const bigInt = 9007199254740993n;  // Note the 'n' suffix
console.log(bigInt + 1n);  // 9007199254740994n (correct!)
// Cannot mix BigInt and Number in arithmetic
// console.log(bigInt + 1);  // TypeError!
 
// String: UTF-16 code units
const str = "Hello 🌍";
console.log(str.length);  // 8 (emoji is 2 UTF-16 code units)
 
// Boolean: true and false (but truthy/falsy adds complexity)
const bool = true;
 
// Primitives vs Objects: the real distinction
const primNum = 42;
const objNum = new Number(42);  // Don't do this!
 
console.log(typeof primNum);  // "number" - primitive
console.log(typeof objNum);   // "object" - wrapper object
 
console.log(primNum === 42);  // true
console.log(objNum === 42);   // false (different types)
console.log(objNum == 42);    // true (coerced)
 
// But primitives can have methods (autoboxing)
console.log((42).toString(16));  // "2a" - hexadecimal
console.log("hello".toUpperCase());  // "HELLO"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

// The infamous type coercion examples
console.log("5" + 3);     // "53" (number to string)
console.log("5" - 3);     // 2 (string to number)
console.log("5" * "3");   // 15 (both to numbers)
console.log(true + true); // 2 (booleans to numbers)
 
// Falsy values: things that coerce to false
console.log(!0);         // true (0 is falsy)
console.log(!"");        // true (empty string is falsy)
console.log(!null);      // true (null is falsy)
console.log(!undefined); // true (undefined is falsy)
console.log(!NaN);       // true (NaN is falsy)
 
// But empty objects/arrays are truthy!
console.log(!{});        // false (empty object is truthy)
console.log(![]);        // false (empty array is truthy)
 
// The == vs === distinction
console.log(0 == "");     // true (type coercion)
console.log(0 === "");    // false (strict equality)
console.log(null == undefined);  // true
console.log(null === undefined); // false

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

// TypedArrays provide C-like fixed-width types
const int8s = new Int8Array(4);    // 4 signed bytes
const uint8s = new Uint8Array(4);  // 4 unsigned bytes
const int32s = new Int32Array(4);  // 4 signed 32-bit ints
const float64s = new Float64Array(4);  // 4 64-bit doubles
 
// Typed arrays have overflow behavior like C
uint8s[0] = 256;  // Wraps to 0
uint8s[1] = -1;   // Wraps to 255
 
// ArrayBuffer: raw binary data buffer
const buffer = new ArrayBuffer(16);  // 16 bytes
const view32 = new Int32Array(buffer);  // View as 4 int32s
const view8 = new Uint8Array(buffer);   // View as 16 uint8s
// Both views access the same underlying memory!
 
// Performance benefit: contiguous memory, no boxing
const regularArray = [1, 2, 3, 4];  // Objects with overhead
const typedArray = new Float64Array([1, 2, 3, 4]);  // Contiguous bytes
 
console.log(typedArray.BYTES_PER_ELEMENT);  // 8