1
2
3
4
5

;; Guile's traditional approach
Source Code → Tree-IL → CPS → Bytecode → VM

;; New baseline compiler approach
Source Code → Tree-IL → Direct Machine Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

;; Traditional interpreted execution
(define (fibonacci n)
  (if (<= n 1)
      n
      (+ (fibonacci (- n 1))
         (fibonacci (- n 2)))))

;; With baseline compiler:
;; - Faster startup (no CPS conversion)
;; - Better debugging (clearer stack traces)
;; - Incremental optimization opportunity
;; - Reduced memory pressure

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

;; Compiler generates direct assembly
(define-compiler-pass (compile-application app)
  (match app
    [($ <application> src proc args)
     (let* ([proc-code (compile-expr proc)]
            [args-code (map compile-expr args)]
            [argc (length args)])
       `(begin
          ,@proc-code
          ,@(append-map (lambda (arg) arg) args-code)
          (call-with-argc ,argc)))]))

;; Register allocation and stack management
(define (allocate-registers exprs)
  (fold (lambda (expr regs)
          (assign-registers expr regs))
        (make-register-set)
        exprs))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

-- Category consists of objects and morphisms (arrows)
-- In programming: types are objects, functions are morphisms

-- Identity morphism
id :: a -> a
id x = x

-- Composition of morphisms
compose :: (b -> c) -> (a -> b) -> (a -> c)
compose g f = \x -> g (f x)

-- Composition is associative
-- compose h (compose g f) = compose (compose h g) f

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

-- Functor maps between categories
class Functor f where
    fmap :: (a -> b) -> f a -> f b

-- Functor laws:
-- fmap id = id
-- fmap (g . f) = fmap g . fmap f

-- Examples of functors
instance Functor [] where
    fmap = map

instance Functor Maybe where
    fmap _ Nothing = Nothing
    fmap f (Just x) = Just (f x)

-- Using functors
numbers = [1, 2, 3, 4]
squared = fmap (^2) numbers  -- [1, 4, 9, 16]

maybeValue = Just 42
doubled = fmap (*2) maybeValue  -- Just 84

1
2
3
4
5
6
7
8
9

-- Natural transformation between functors
-- Safe head function using Maybe
safeHead :: [a] -> Maybe a
safeHead [] = Nothing
safeHead (x:_) = Just x

-- Length is a natural transformation from [] to Const Int
length :: [a] -> Int
-- Satisfies: length . fmap f = length (naturality condition)

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

-- Monad as a category theory concept
class Functor m => Monad m where
    return :: a -> m a     -- Unit natural transformation
    (>>=) :: m a -> (a -> m b) -> m b  -- Multiplication

-- Monad laws (category theory requirements):
-- Left identity: return a >>= f = f a
-- Right identity: m >>= return = m
-- Associativity: (m >>= f) >>= g = m >>= (\x -> f x >>= g)

-- IO Monad example
greetUser :: IO ()
greetUser = do
    putStrLn "What's your name?"
    name <- getLine
    putStrLn ("Hello, " ++ name)

-- Desugared version
greetUser' =
    putStrLn "What's your name?" >>= \_ ->
    getLine >>= \name ->
    putStrLn ("Hello, " ++ name)

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

-- Kleisli category for a monad
-- Objects: same as base category
-- Morphisms: a -> m b (where m is a monad)

-- Kleisli composition
(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> (a -> m c)
f >=> g = \x -> f x >>= g

-- Example: composing functions that might fail
safeDivide :: Double -> Double -> Maybe Double
safeDivide _ 0 = Nothing
safeDivide x y = Just (x / y)

safeSquareRoot :: Double -> Maybe Double
safeSquareRoot x
    | x < 0 = Nothing
    | otherwise = Just (sqrt x)

-- Kleisli composition
safeComputation :: Double -> Double -> Maybe Double
safeComputation x y = safeDivide x y >=> safeSquareRoot

 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

;; Building abstractions with procedures
(define (square x) (* x x))

(define (sum-of-squares x y)
  (+ (square x) (square y)))

;; Higher-order procedures
(define (sum term a next b)
  (if (> a b)
      0
      (+ (term a)
         (sum term (next a) next b))))

;; Using higher-order procedures
(define (sum-cubes a b)
  (sum (lambda (x) (* x x x))
       a
       (lambda (x) (+ x 1))
       b))

(define (pi-sum a b)
  (define (pi-term x)
    (/ 1.0 (* x (+ x 2))))
  (define (pi-next x)
    (+ x 4))
  (sum pi-term a pi-next b))

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

;; Abstract data types
(define (make-rat n d)
  (let ((g (gcd n d)))
    (cons (/ n g) (/ d g))))

(define (numer x) (car x))
(define (denom x) (cdr x))

(define (add-rat x y)
  (make-rat (+ (* (numer x) (denom y))
               (* (numer y) (denom x)))
            (* (denom x) (denom y))))

;; Using rational numbers
(define one-half (make-rat 1 2))
(define one-third (make-rat 1 3))
(define sum (add-rat one-half one-third))  ; 5/6

 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

;; Metacircular evaluator - Scheme interpreter in Scheme
(define (eval exp env)
  (cond ((self-evaluating? exp) exp)
        ((variable? exp) (lookup-variable-value exp env))
        ((quoted? exp) (text-of-quotation exp))
        ((assignment? exp) (eval-assignment exp env))
        ((definition? exp) (eval-definition exp env))
        ((if? exp) (eval-if exp env))
        ((lambda? exp) (make-procedure (lambda-parameters exp)
                                       (lambda-body exp)
                                       env))
        ((begin? exp) (eval-sequence (begin-actions exp) env))
        ((cond? exp) (eval (cond->if exp) env))
        ((application? exp)
         (apply (eval (operator exp) env)
                (list-of-values (operands exp) env)))))

(define (apply procedure arguments)
  (cond ((primitive-procedure? procedure)
         (apply-primitive-procedure procedure arguments))
        ((compound-procedure? procedure)
         (eval-sequence
           (procedure-body procedure)
           (extend-environment
             (procedure-parameters procedure)
             arguments
             (procedure-environment procedure))))))

1
2
3
4
5
6
7
8
9

# Basic process information
cat /proc/PID/stat    # Process statistics
cat /proc/PID/status  # Human-readable status
cat /proc/PID/cmdline # Command line that started process
cat /proc/PID/environ # Environment variables

# Process tree relationships
cat /proc/PID/task/   # Thread information
ls /proc/PID/fd/      # Open file descriptors

 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
37
38
39
40
41
42
43
44
45
46
47
48
49

import os
import time
from pathlib import Path

def monitor_process_safely(pid):
    """Handle race conditions when monitoring processes"""
    try:
        # Check if process exists
        proc_path = Path(f"/proc/{pid}")
        if not proc_path.exists():
            return None

        # Read multiple files atomically (as much as possible)
        stat_path = proc_path / "stat"
        status_path = proc_path / "status"

        # Race condition: process might disappear between checks
        with stat_path.open() as f:
            stat_data = f.read().strip()

        # Process might have been replaced by another with same PID
        with status_path.open() as f:
            status_data = f.read()

        return {
            'stat': stat_data,
            'status': status_data,
            'timestamp': time.time()
        }

    except (FileNotFoundError, ProcessLookupError, PermissionError):
        # Process disappeared or access denied
        return None

# Handle PID reuse
def track_process_with_start_time(pid):
    """Use start time to identify unique process instances"""
    try:
        with open(f"/proc/{pid}/stat") as f:
            fields = f.read().split()
            start_time = int(fields[21])  # Process start time

        return {
            'pid': pid,
            'start_time': start_time,
            'unique_id': f"{pid}_{start_time}"
        }
    except (FileNotFoundError, IndexError):
        return None

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

# Process accounting (if enabled)
sudo apt-get install acct
sudo accton /var/log/wtmp

# Monitor process creation/termination
lastcomm | head -10

# Real-time process monitoring
# Using bpftrace (eBPF)
sudo bpftrace -e '
tracepoint:syscalls:sys_enter_execve {
    printf("PID %d exec: %s\n", pid, str(args->filename));
}

tracepoint:syscalls:sys_enter_exit_group {
    printf("PID %d exit\n", pid);
}'

# Using perf events
sudo perf record -e sched:sched_process_exec,sched:sched_process_exit -a sleep 10
sudo perf script

 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

# Container process monitoring
def monitor_container_processes(container_id):
    """Monitor processes inside containers"""
    try:
        # Find container's PID namespace
        with open(f"/sys/fs/cgroup/memory/docker/{container_id}/cgroup.procs") as f:
            container_pids = [int(line.strip()) for line in f if line.strip()]

        processes = []
        for pid in container_pids:
            try:
                with open(f"/proc/{pid}/stat") as f:
                    stat_data = f.read().split()
                    processes.append({
                        'pid': pid,
                        'name': stat_data[1].strip('()'),
                        'state': stat_data[2],
                        'ppid': int(stat_data[3])
                    })
            except FileNotFoundError:
                continue  # Process disappeared

        return processes
    except FileNotFoundError:
        return []  # Container not found