@booklib/skills 1.2.0 → 1.3.1

package/domain-driven-design/scripts/scaffold.py

@@ -0,0 +1,421 @@
+#!/usr/bin/env python3
+"""
+DDD Scaffold — generates aggregate building blocks for a bounded context.
+Usage: python scaffold.py <AggregateName> [--lang python|kotlin|java] [--output-dir ./]
+"""
+
+import argparse
+import sys
+from pathlib import Path
+from string import Template
+
+# ---------------------------------------------------------------------------
+# Templates
+# ---------------------------------------------------------------------------
+
+PYTHON_AGGREGATE = Template('''\
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import List
+from .${name}Id import ${name}Id
+from .${name}Events import ${name}Created, ${name}Event
+
+
+@dataclass
+class ${name}:
+    """Aggregate root for ${name}."""
+
+    id: ${name}Id
+    _events: List[${name}Event] = field(default_factory=list, init=False, repr=False)
+
+    # ------------------------------------------------------------------
+    # Factory method — the only sanctioned way to create a ${name}.
+    # ------------------------------------------------------------------
+    @classmethod
+    def create(cls, id: ${name}Id, **kwargs) -> "${name}":
+        instance = cls(id=id)
+        instance._check_invariants()
+        instance._record(${name}Created(aggregate_id=id))
+        return instance
+
+    # ------------------------------------------------------------------
+    # Commands — each mutates state and records an event.
+    # ------------------------------------------------------------------
+
+    # def rename(self, new_name: str) -> None:
+    #     if not new_name.strip():
+    #         raise ValueError("Name must not be blank.")
+    #     self.name = new_name
+    #     self._record(${name}Renamed(aggregate_id=self.id, name=new_name))
+
+    # ------------------------------------------------------------------
+    # Domain events
+    # ------------------------------------------------------------------
+    def pull_events(self) -> List[${name}Event]:
+        """Return and clear pending domain events."""
+        events, self._events = self._events, []
+        return events
+
+    def _record(self, event: ${name}Event) -> None:
+        self._events.append(event)
+
+    # ------------------------------------------------------------------
+    # Invariants
+    # ------------------------------------------------------------------
+    def _check_invariants(self) -> None:
+        """Raise if the aggregate is in an invalid state."""
+        if self.id is None:
+            raise ValueError("${name} must have an ID.")
+''')
+
+PYTHON_ID = Template('''\
+from __future__ import annotations
+from dataclasses import dataclass
+import uuid
+
+
+@dataclass(frozen=True)
+class ${name}Id:
+    """Value Object — identity of a ${name} aggregate."""
+
+    value: str
+
+    def __post_init__(self) -> None:
+        if not self.value or not self.value.strip():
+            raise ValueError("${name}Id must not be blank.")
+
+    @classmethod
+    def generate(cls) -> "${name}Id":
+        return cls(value=str(uuid.uuid4()))
+
+    @classmethod
+    def from_string(cls, raw: str) -> "${name}Id":
+        return cls(value=raw)
+
+    def __str__(self) -> str:
+        return self.value
+''')
+
+PYTHON_REPOSITORY = Template('''\
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from typing import Optional
+from .${name}Id import ${name}Id
+from .${name} import ${name}
+
+
+class ${name}Repository(ABC):
+    """Port (interface) for ${name} persistence.
+
+    Concrete adapters live in the infrastructure layer.
+    """
+
+    @abstractmethod
+    def find_by_id(self, id: ${name}Id) -> Optional[${name}]:
+        """Return the aggregate or None if not found."""
+
+    @abstractmethod
+    def save(self, aggregate: ${name}) -> None:
+        """Persist all state changes."""
+
+    @abstractmethod
+    def delete(self, id: ${name}Id) -> None:
+        """Remove the aggregate."""
+
+    @abstractmethod
+    def exists(self, id: ${name}Id) -> bool:
+        """Check existence without loading the aggregate."""
+''')
+
+PYTHON_EVENTS = Template('''\
+from __future__ import annotations
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import ClassVar
+from .${name}Id import ${name}Id
+
+
+@dataclass(frozen=True)
+class ${name}Event:
+    """Base class for all ${name} domain events."""
+
+    event_type: ClassVar[str]
+    aggregate_id: ${name}Id
+    occurred_at: datetime = field(
+        default_factory=lambda: datetime.now(tz=timezone.utc)
+    )
+
+
+@dataclass(frozen=True)
+class ${name}Created(${name}Event):
+    """Raised when a new ${name} is created."""
+
+    event_type: ClassVar[str] = "${name}Created"
+
+
+# Add more events below as your domain grows, for example:
+# @dataclass(frozen=True)
+# class ${name}Renamed(${name}Event):
+#     event_type: ClassVar[str] = "${name}Renamed"
+#     name: str = ""
+''')
+
+# ---------------------------------------------------------------------------
+# Kotlin templates
+# ---------------------------------------------------------------------------
+
+KOTLIN_AGGREGATE = Template('''\
+package com.example.${lname}
+
+import java.time.Instant
+
+class ${name}(val id: ${name}Id) {
+
+    private val _events: MutableList<${name}Event> = mutableListOf()
+    val events: List<${name}Event> get() = _events.toList()
+
+    companion object {
+        /** Factory — the only way to create a valid ${name}. */
+        fun create(id: ${name}Id): ${name} {
+            val agg = ${name}(id)
+            agg.checkInvariants()
+            agg.record(${name}Created(aggregateId = id))
+            return agg
+        }
+    }
+
+    /** Pull and clear pending domain events. */
+    fun pullEvents(): List<${name}Event> {
+        val copy = _events.toList()
+        _events.clear()
+        return copy
+    }
+
+    private fun record(event: ${name}Event) { _events.add(event) }
+
+    private fun checkInvariants() {
+        // Add invariant assertions here.
+    }
+}
+''')
+
+KOTLIN_ID = Template('''\
+package com.example.${lname}
+
+import java.util.UUID
+
+@JvmInline
+value class ${name}Id(val value: String) {
+    init {
+        require(value.isNotBlank()) { "${name}Id must not be blank." }
+    }
+
+    companion object {
+        fun generate(): ${name}Id = ${name}Id(UUID.randomUUID().toString())
+        fun of(raw: String): ${name}Id = ${name}Id(raw)
+    }
+
+    override fun toString(): String = value
+}
+''')
+
+KOTLIN_REPOSITORY = Template('''\
+package com.example.${lname}
+
+interface ${name}Repository {
+    fun findById(id: ${name}Id): ${name}?
+    fun save(aggregate: ${name})
+    fun delete(id: ${name}Id)
+    fun exists(id: ${name}Id): Boolean
+}
+''')
+
+KOTLIN_EVENTS = Template('''\
+package com.example.${lname}
+
+import java.time.Instant
+
+sealed class ${name}Event {
+    abstract val aggregateId: ${name}Id
+    abstract val occurredAt: Instant
+}
+
+data class ${name}Created(
+    override val aggregateId: ${name}Id,
+    override val occurredAt: Instant = Instant.now()
+) : ${name}Event()
+
+// Add more events as the domain grows:
+// data class ${name}Renamed(
+//     override val aggregateId: ${name}Id,
+//     val name: String,
+//     override val occurredAt: Instant = Instant.now()
+// ) : ${name}Event()
+''')
+
+# ---------------------------------------------------------------------------
+# Java templates
+# ---------------------------------------------------------------------------
+
+JAVA_AGGREGATE = Template('''\
+package com.example.${lname};
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+
+public final class ${name} {
+
+    private final ${name}Id id;
+    private final List<${name}Event> events = new ArrayList<>();
+
+    private ${name}(${name}Id id) {
+        this.id = Objects.requireNonNull(id, "id must not be null");
+    }
+
+    /** Factory — the only way to create a valid ${name}. */
+    public static ${name} create(${name}Id id) {
+        var agg = new ${name}(id);
+        agg.checkInvariants();
+        agg.record(new ${name}Created(id));
+        return agg;
+    }
+
+    public ${name}Id getId() { return id; }
+
+    /** Pull and clear pending domain events. */
+    public List<${name}Event> pullEvents() {
+        var copy = List.copyOf(events);
+        events.clear();
+        return copy;
+    }
+
+    private void record(${name}Event event) { events.add(event); }
+
+    private void checkInvariants() {
+        // Add invariant assertions here.
+    }
+}
+''')
+
+JAVA_ID = Template('''\
+package com.example.${lname};
+
+import java.util.Objects;
+import java.util.UUID;
+
+public record ${name}Id(String value) {
+
+    public ${name}Id {
+        Objects.requireNonNull(value, "value must not be null");
+        if (value.isBlank()) throw new IllegalArgumentException("${name}Id must not be blank.");
+    }
+
+    public static ${name}Id generate() { return new ${name}Id(UUID.randomUUID().toString()); }
+    public static ${name}Id of(String raw) { return new ${name}Id(raw); }
+
+    @Override public String toString() { return value; }
+}
+''')
+
+JAVA_REPOSITORY = Template('''\
+package com.example.${lname};
+
+import java.util.Optional;
+
+public interface ${name}Repository {
+    Optional<${name}> findById(${name}Id id);
+    void save(${name} aggregate);
+    void delete(${name}Id id);
+    boolean exists(${name}Id id);
+}
+''')
+
+JAVA_EVENTS = Template('''\
+package com.example.${lname};
+
+import java.time.Instant;
+
+public sealed interface ${name}Event permits ${name}Created {
+    ${name}Id aggregateId();
+    Instant occurredAt();
+}
+
+record ${name}Created(${name}Id aggregateId, Instant occurredAt) implements ${name}Event {
+    ${name}Created(${name}Id aggregateId) { this(aggregateId, Instant.now()); }
+}
+
+// Add more events as the domain grows:
+// record ${name}Renamed(${name}Id aggregateId, String name, Instant occurredAt)
+//     implements ${name}Event { ... }
+''')
+
+TEMPLATES = {
+    "python": {
+        "ext": "py",
+        "aggregate": PYTHON_AGGREGATE,
+        "id": PYTHON_ID,
+        "repository": PYTHON_REPOSITORY,
+        "events": PYTHON_EVENTS,
+    },
+    "kotlin": {
+        "ext": "kt",
+        "aggregate": KOTLIN_AGGREGATE,
+        "id": KOTLIN_ID,
+        "repository": KOTLIN_REPOSITORY,
+        "events": KOTLIN_EVENTS,
+    },
+    "java": {
+        "ext": "java",
+        "aggregate": JAVA_AGGREGATE,
+        "id": JAVA_ID,
+        "repository": JAVA_REPOSITORY,
+        "events": JAVA_EVENTS,
+    },
+}
+
+
+def write(path: Path, content: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(content)
+    print(f"  Created: {path}")
+
+
+def scaffold(name: str, lang: str, output_dir: Path) -> None:
+    t = TEMPLATES[lang]
+    ext = t["ext"]
+    ctx = {"name": name, "lname": name.lower()}
+    files = {
+        f"{name}.{ext}": t["aggregate"],
+        f"{name}Id.{ext}": t["id"],
+        f"{name}Repository.{ext}": t["repository"],
+        f"{name}Events.{ext}": t["events"],
+    }
+    print(f"\nScaffolding DDD aggregate '{name}' ({lang}) in {output_dir}/\n")
+    for filename, tmpl in files.items():
+        write(output_dir / filename, tmpl.substitute(ctx))
+
+    print("\nNext steps:")
+    print(f"  1. Implement your domain commands inside {name}.{ext}")
+    print(f"  2. Add concrete repository in infrastructure/ (implements {name}Repository)")
+    print(f"  3. Publish events from {name}Events.{ext} via a message broker")
+    print(f"  4. Keep the aggregate free of infrastructure concerns\n")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Scaffold DDD aggregate building blocks.")
+    parser.add_argument("name", help="Aggregate name (PascalCase), e.g. Order")
+    parser.add_argument("--lang", choices=["python", "kotlin", "java"], default="python")
+    parser.add_argument("--output-dir", default=".", type=Path)
+    args = parser.parse_args()
+
+    if not args.name[0].isupper():
+        print(f"ERROR: AggregateName should be PascalCase (got '{args.name}').", file=sys.stderr)
+        sys.exit(1)
+
+    scaffold(args.name, args.lang, args.output_dir)
+
+
+if __name__ == "__main__":
+    main()

package/effective-java/evals/evals.json

@@ -0,0 +1,46 @@
+{
+  "evals": [
+    {
+      "id": "eval-01-public-mutable-fields-no-builder",
+      "prompt": "Review this Java code:\n\n```java\npublic class HttpRequest {\n    public String url;\n    public String method;\n    public Map<String, String> headers;\n    public String body;\n    public int timeoutMs;\n    public boolean followRedirects;\n    public int maxRetries;\n    public String authToken;\n    public boolean verifySsl;\n    public String proxyHost;\n    public int proxyPort;\n    \n    public HttpRequest(String url, String method, Map<String, String> headers,\n                       String body, int timeoutMs, boolean followRedirects,\n                       int maxRetries, String authToken, boolean verifySsl,\n                       String proxyHost, int proxyPort) {\n        this.url = url;\n        this.method = method;\n        this.headers = headers;\n        this.body = body;\n        this.timeoutMs = timeoutMs;\n        this.followRedirects = followRedirects;\n        this.maxRetries = maxRetries;\n        this.authToken = authToken;\n        this.verifySsl = verifySsl;\n        this.proxyHost = proxyHost;\n        this.proxyPort = proxyPort;\n    }\n}\n\n// Typical usage:\nHttpRequest req = new HttpRequest(\n    \"https://api.example.com/data\",\n    \"POST\",\n    new HashMap<>(),\n    \"{\\\"key\\\": \\\"value\\\"}\",\n    5000,\n    true,\n    3,\n    null,\n    true,\n    null,\n    0\n);\nreq.headers.put(\"Content-Type\", \"application/json\");\n```",
+      "expectations": [
+        "Flags Item 2 (Builder pattern): 11-parameter constructor is a telescoping constructor — callers cannot tell what the 6th argument (boolean) means at the call site",
+        "Flags that all fields are public — violates the 'minimal accessibility' review criterion (Mode 2: Class design — 'Minimal accessibility?'); enables uncontrolled mutation that Item 17 (minimize mutability) and the private final recommendation are meant to prevent",
+        "Flags Item 17 (minimize mutability): HttpRequest should be immutable — a request is a value that shouldn't change after construction",
+        "Flags Item 50 (defensive copies): headers is a mutable Map passed directly — external code can mutate it after the fact; req.headers.put() after construction is a symptom",
+        "Recommends the Builder pattern with a fluent API: HttpRequest.builder(url).method(\"POST\").timeout(5000).build()",
+        "Notes that the two boolean parameters (followRedirects, verifySsl) at positions 6 and 9 are especially dangerous — easy to swap without compile-time error",
+        "Suggests making all fields private final, constructor private, and providing only getters",
+        "May note that modern Java could use a Record for simpler cases, but Builder is more appropriate here due to many optional fields"
+      ]
+    },
+    {
+      "id": "eval-02-raw-types-generics",
+      "prompt": "Review this Java code:\n\n```java\npublic class EventBus {\n    private Map subscribers = new HashMap();\n    \n    public void subscribe(String eventType, Object handler) {\n        List handlers = (List) subscribers.get(eventType);\n        if (handlers == null) {\n            handlers = new ArrayList();\n            subscribers.put(eventType, handlers);\n        }\n        handlers.add(handler);\n    }\n    \n    public void publish(String eventType, Object event) {\n        List handlers = (List) subscribers.get(eventType);\n        if (handlers != null) {\n            for (Object handler : handlers) {\n                try {\n                    // Cast handler to expected type and call it\n                    ((java.util.function.Consumer) handler).accept(event);\n                } catch (ClassCastException e) {\n                    System.err.println(\"Handler type mismatch for event: \" + eventType);\n                }\n            }\n        }\n    }\n    \n    public List getHandlersForEvent(String eventType) {\n        return (List) subscribers.get(eventType);\n    }\n}\n\n// Usage:\nEventBus bus = new EventBus();\nbus.subscribe(\"USER_CREATED\", (Consumer<String>) name -> System.out.println(\"User created: \" + name));\nbus.subscribe(\"USER_CREATED\", (Consumer<Integer>) id -> System.out.println(\"ID: \" + id)); // Wrong type, no compile error\nbus.publish(\"USER_CREATED\", \"Alice\"); // Second handler will ClassCastException at runtime\n```",
+      "expectations": [
+        "Flags Item 26 (no raw types): Map, HashMap, List, ArrayList, and Consumer are all used as raw types — the entire class loses type safety",
+        "Explains the consequence: the second bus.subscribe() with Consumer<Integer> compiles silently but causes ClassCastException at runtime — exactly the bug raw types enable",
+        "Notes that catching ClassCastException to handle type mismatches is a design smell that would disappear with proper generics",
+        "Recommends a generic EventBus<T> or a type-safe subscriber model using Class<T> as the key instead of String",
+        "Suggests a typed design: subscribe(Class<T> eventType, Consumer<T> handler) with Map<Class<?>, List<Consumer<?>>> subscribers",
+        "Notes that getHandlersForEvent returns a raw List — callers cannot know the element type at compile time",
+        "May mention Item 27 (eliminate unchecked warnings): this code would generate many unchecked cast warnings that are being suppressed or ignored",
+        "Notes that String event type keys are fragile — typos cause silent misses; Class<T> as the key is self-documenting and refactoring-safe"
+      ]
+    },
+    {
+      "id": "eval-03-immutable-value-class",
+      "prompt": "Review this Java code:\n\n```java\npublic final class EmailAddress {\n    private final String localPart;\n    private final String domain;\n    \n    private EmailAddress(String localPart, String domain) {\n        this.localPart = localPart;\n        this.domain = domain;\n    }\n    \n    public static EmailAddress of(String email) {\n        Objects.requireNonNull(email, \"email must not be null\");\n        String trimmed = email.trim().toLowerCase(Locale.ROOT);\n        int atIndex = trimmed.indexOf('@');\n        if (atIndex <= 0 || atIndex == trimmed.length() - 1) {\n            throw new IllegalArgumentException(\"Invalid email address: \" + email);\n        }\n        String local = trimmed.substring(0, atIndex);\n        String dom = trimmed.substring(atIndex + 1);\n        return new EmailAddress(local, dom);\n    }\n    \n    public String getLocalPart() { return localPart; }\n    public String getDomain() { return domain; }\n    \n    public String toCanonicalString() {\n        return localPart + \"@\" + domain;\n    }\n    \n    @Override\n    public boolean equals(Object o) {\n        if (this == o) return true;\n        if (!(o instanceof EmailAddress)) return false;\n        EmailAddress that = (EmailAddress) o;\n        return localPart.equals(that.localPart) && domain.equals(that.domain);\n    }\n    \n    @Override\n    public int hashCode() {\n        return Objects.hash(localPart, domain);\n    }\n    \n    @Override\n    public String toString() {\n        return toCanonicalString();\n    }\n}\n```",
+      "expectations": [
+        "Recognizes this as a well-designed immutable value class and says so explicitly",
+        "Praises Item 17 (minimize mutability): class is final, all fields are private final, no setters",
+        "Praises Item 1 (static factory method): EmailAddress.of() gives a meaningful name, allows validation before construction, and can potentially cache instances",
+        "Praises Item 49 (parameter validation): uses Objects.requireNonNull and throws IllegalArgumentException with useful context",
+        "Praises Items 10-12 (equals/hashCode/toString contract): properly overridden, equals checks instanceof, hashCode uses Objects.hash, toString returns a useful representation",
+        "Praises normalization in the factory: trim() and toLowerCase() ensure canonical representation, meaning EmailAddress.of(\"USER@Example.COM\") equals EmailAddress.of(\"user@example.com\")",
+        "Does NOT manufacture fake issues just to have something to say",
+        "May offer minor optional suggestions (e.g., more thorough RFC-5321 validation, caching for common domains, a Java Record equivalent in newer Java versions) but clearly frames them as enhancements"
+      ]
+    }
+  ]
+}

package/effective-java/examples/after.md

@@ -0,0 +1,83 @@
+# After
+
+An immutable `ShippingAddress` value class built with a fluent Builder, validated at construction time so that no corrupt instance can ever exist.
+
+```java
+public final class ShippingAddress {
+    private final String recipientName;
+    private final String streetLine1;
+    private final String streetLine2;   // nullable — optional field
+    private final String city;
+    private final String stateCode;
+    private final String postalCode;
+    private final String countryCode;
+    private final boolean residential;
+
+    private ShippingAddress(Builder builder) {
+        this.recipientName = builder.recipientName;
+        this.streetLine1   = builder.streetLine1;
+        this.streetLine2   = builder.streetLine2;
+        this.city          = builder.city;
+        this.stateCode     = builder.stateCode;
+        this.postalCode    = builder.postalCode;
+        this.countryCode   = builder.countryCode;
+        this.residential   = builder.residential;
+    }
+
+    public static Builder builder(String recipientName, String streetLine1,
+                                  String city, String postalCode, String countryCode) {
+        return new Builder(recipientName, streetLine1, city, postalCode, countryCode);
+    }
+
+    // Accessors only — no setters
+    public String recipientName() { return recipientName; }
+    public String streetLine1()   { return streetLine1; }
+    public Optional<String> streetLine2() { return Optional.ofNullable(streetLine2); }
+    public String city()          { return city; }
+    public String stateCode()     { return stateCode; }
+    public String postalCode()    { return postalCode; }
+    public String countryCode()   { return countryCode; }
+    public boolean isResidential(){ return residential; }
+
+    public static final class Builder {
+        // Required fields set via constructor
+        private final String recipientName;
+        private final String streetLine1;
+        private final String city;
+        private final String postalCode;
+        private final String countryCode;
+        // Optional fields
+        private String streetLine2;
+        private String stateCode = "";
+        private boolean residential = true;
+
+        private Builder(String recipientName, String streetLine1,
+                        String city, String postalCode, String countryCode) {
+            this.recipientName = Objects.requireNonNull(recipientName, "recipientName");
+            this.streetLine1   = Objects.requireNonNull(streetLine1,   "streetLine1");
+            this.city          = Objects.requireNonNull(city,           "city");
+            this.postalCode    = Objects.requireNonNull(postalCode,     "postalCode");
+            this.countryCode   = Objects.requireNonNull(countryCode,    "countryCode");
+        }
+
+        public Builder streetLine2(String val) { this.streetLine2 = val; return this; }
+        public Builder stateCode(String val)   { this.stateCode = val;   return this; }
+        public Builder commercial()            { this.residential = false; return this; }
+        public ShippingAddress build()         { return new ShippingAddress(this); }
+    }
+}
+
+// Usage — required fields enforced; optional fields have readable names
+ShippingAddress addr = ShippingAddress
+    .builder("Jane Doe", "742 Evergreen Terrace", "Springfield", "62701", "US")
+    .stateCode("IL")
+    .commercial()
+    .build();
+```
+
+Key improvements:
+- Builder pattern eliminates the telescoping constructor problem — required fields are in the builder constructor, optional fields use fluent setters (Item 2: Builder when many parameters)
+- All fields are `private final` — the class is immutable after construction (Item 17: Minimize mutability)
+- `Objects.requireNonNull` validates all required fields at construction time — corrupt objects are impossible to create (Item 49: Validate parameters)
+- `Optional<String>` return type for `streetLine2` explicitly signals to callers that this value may be absent (Item 55: Return Optional judiciously)
+- `final` class prevents subclasses from breaking immutability guarantees (Item 17)

package/effective-java/examples/before.md

@@ -0,0 +1,37 @@
+# Before
+
+A Java class representing a shipping address with public mutable fields, no validation, and no safe construction — making it trivial to create corrupt objects.
+
+```java
+public class ShippingAddress {
+    public String recipientName;
+    public String streetLine1;
+    public String streetLine2;
+    public String city;
+    public String stateCode;
+    public String postalCode;
+    public String countryCode;
+    public boolean isResidential;
+
+    public ShippingAddress() {}
+
+    public ShippingAddress(String recipientName, String streetLine1,
+                           String streetLine2, String city, String stateCode,
+                           String postalCode, String countryCode,
+                           boolean isResidential) {
+        this.recipientName = recipientName;
+        this.streetLine1 = streetLine1;
+        this.streetLine2 = streetLine2;
+        this.city = city;
+        this.stateCode = stateCode;
+        this.postalCode = postalCode;
+        this.countryCode = countryCode;
+        this.isResidential = isResidential;
+    }
+}
+
+// Usage — nothing prevents corrupt construction
+ShippingAddress addr = new ShippingAddress();
+addr.city = "Austin";
+// postalCode, countryCode, recipientName all null — silently broken
+```