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

# Illustration of Perlis's insights through code examples

# "A language that doesn't affect the way you think about programming..."
# Compare imperative vs functional approaches:

# Imperative thinking - focus on HOW
def sum_squares_imperative(numbers):
    total = 0
    for num in numbers:
        square = num * num
        total += square
    return total

# Functional thinking - focus on WHAT
def sum_squares_functional(numbers):
    return sum(num * num for num in numbers)

# The functional approach changes how we think about the problem
# - Composition over mutation
# - Expressions over statements
# - Transformation over iteration

# "Simplicity does not precede complexity, but follows it"
# This elegant recursive solution emerged after understanding complex iteration:
def fibonacci_simple(n, memo={}):
    if n in memo:
        return memo[n]
    if n <= 2:
        return 1
    memo[n] = fibonacci_simple(n-1, memo) + fibonacci_simple(n-2, memo)
    return memo[n]

# "It is easier to write an incorrect program than understand a correct one"
# This correct but subtle algorithm requires deep understanding:
def binary_search(arr, target):
    left, right = 0, len(arr) - 1

    while left <= right:  # Note: <= not <
        mid = left + (right - left) // 2  # Avoids overflow

        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1

    return -1

 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

// Steele's philosophy illustrated through Java's evolution
// Java started small but grew through community needs

// Early Java (1.0) - basic object orientation
public class Stack {
    private Object[] elements;
    private int size = 0;

    public void push(Object e) {
        ensureCapacity();
        elements[size++] = e;
    }

    public Object pop() {
        if (size == 0) return null;
        return elements[--size];
    }
}

// Java 5 - Generics added based on user demand for type safety
public class Stack<E> {
    private E[] elements;
    private int size = 0;

    @SuppressWarnings("unchecked")
    public Stack() {
        elements = (E[]) new Object[10];
    }

    public void push(E e) {
        ensureCapacity();
        elements[size++] = e;
    }

    public E pop() {
        if (size == 0) return null;
        return elements[--size];
    }
}

// Modern Java - Var keyword, lambda expressions, streams
var numbers = List.of(1, 2, 3, 4, 5);
var evenSquares = numbers.stream()
    .filter(n -> n % 2 == 0)
    .map(n -> n * n)
    .collect(toList());

// Each addition addressed real user pain points while maintaining compatibility

 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

# Demonstration of growing complexity from simple components
# Like Steele's talk, we can build complex programs from simple parts

# Simple building blocks
def compose(f, g):
    """Combine two functions into one"""
    return lambda x: f(g(x))

def partial(func, *args):
    """Create new function with some arguments pre-filled"""
    return lambda *remaining: func(*args, *remaining)

def pipe(*functions):
    """Chain functions together"""
    from functools import reduce
    return reduce(compose, functions)

# Growing complexity through composition
add_one = lambda x: x + 1
multiply_by_two = lambda x: x * 2
square = lambda x: x * x

# Simple transformations
transform1 = compose(square, add_one)  # (x + 1)²

# More complex pipeline
complex_transform = pipe(
    add_one,
    multiply_by_two,
    square,
    partial(max, 10)  # Ensure minimum value of 10
)

# The power comes from combining simple, well-understood parts
data = [1, 2, 3, 4, 5]
result = [complex_transform(x) for x in data]
print(result)  # [16, 36, 100, 100, 121]

 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

;; Clojure embodies Steele's "growing a language" philosophy

;; Simple data structures as the foundation
(def user {:name "Alice" :age 30 :email "[email protected]"})

;; Functions that work on data
(defn adult? [person]
  (>= (:age person) 18))

(defn format-user [person]
  (str (:name person) " <" (:email person) ">"))

;; Composition and transformation
(->> users
     (filter adult?)
     (map format-user)
     (take 10)
     (into []))

;; The language grew organically:
;; - Core data structures (maps, vectors, sets)
;; - Sequence abstraction
;; - Transducers (added later based on usage patterns)
;; - Spec (validation and generative testing)
;; - Each addition addressed real community needs

 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
50

// Example of growing JavaScript complexity following roadmap progression

// 1. Foundation - Basic JavaScript
function calculateTotal(items) {
  let total = 0;
  for (let i = 0; i < items.length; i++) {
    total += items[i].price;
  }
  return total;
}

// 2. Intermediate - Modern JavaScript features
const calculateTotal = (items) =>
  items.reduce((total, item) => total + item.price, 0);

// 3. Advanced - Framework integration (React example)
import React, { useMemo } from "react";

const ShoppingCart = ({ items }) => {
  const total = useMemo(
    () => items.reduce((sum, item) => sum + item.price, 0),
    [items],
  );

  return (
    <div>
      <h2>Total: ${total.toFixed(2)}</h2>
      {items.map((item) => (
        <CartItem key={item.id} item={item} />
      ))}
    </div>
  );
};

// 4. Expert - Performance optimization with virtualization
import { FixedSizeList as List } from "react-window";

const VirtualizedCart = ({ items }) => {
  const Row = ({ index, style }) => (
    <div style={style}>
      <CartItem item={items[index]} />
    </div>
  );

  return (
    <List height={600} itemCount={items.length} itemSize={80}>
      {Row}
    </List>
  );
};

 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

# Apply language design principles to API design

# Bad API - doesn't grow well
class UserManager:
    def create_user_with_email(self, name, email):
        pass

    def create_user_with_phone(self, name, phone):
        pass

    def create_user_with_email_and_phone(self, name, email, phone):
        pass

# Good API - designed for growth
class User:
    def __init__(self, name, **contact_methods):
        self.name = name
        self.contacts = contact_methods

    def add_contact(self, method, value):
        self.contacts[method] = value

    def remove_contact(self, method):
        return self.contacts.pop(method, None)

# This approach follows Steele's principles:
# - Simple core (User with name)
# - Extensible mechanism (contact_methods dict)
# - Growth without breaking changes (new contact types)