Luminoid's Site

A working mental model of large language models, written for people who use Claude / ChatGPT / Gemini / Claude Code daily and want to understand what’s actually running under the hood. The post is layered: the first stretch is the whole thing in plain language, explaining behaviours you’ve already noticed (hallucination, the “let’s think step by step” trick, why Claude can’t count rs in “strawberry”); the middle goes into the architecture with every symbol defined for anyone who wants the math; the last part covers training, inference economics, and what’s actually new at the frontier in 2026. Stop reading whenever you have enough; the architecture section is opt-in.

The thing about 2012 that’s easy to forget is that for the first five years of iOS, UIKit was a junior framework. AppKit had been shipping since 1989; iOS was a phone OS that borrowed Cocoa’s runtime and naming conventions but quietly did without the harder pieces. There was no constraint-based layout on iOS until 2012. There was no NSAttributedString accepted by UILabel until 2012. There was no grid view, no proper view controller containment API, no canonical async substrate. Developers building iPhone apps reached for CGRect.frame, sprung-and-strut autoresizing masks, and Core Text bridges, while their colleagues on the Mac had stopped writing that kind of code years earlier.

The thing I keep coming back to about 2011 is that almost none of the APIs revealed that June are alive in the form they shipped. Core Data’s iCloud integration (the transaction-log mechanism that the 2011 reveal pitched) was deprecated in iOS 10 in 2016. UILocalNotification was deprecated the same year. Storyboards lost the argument in most production codebases. ARC’s __weak keyword survived as a curiosity in mixed Obj-C/Swift bridging headers, and the rest of manual memory management died with Swift. And yet, when I read the seven sessions I revisited this week, every modern iOS app I touch is still organised around the ideas those sessions argued for. The API surface got rewritten. The conceptual model didn’t.

2010 was bracketed by two products. The iPad shipped on April 3 and gave Apple a second iOS device weeks before WWDC had a chance to teach it. iOS 4 shipped on June 21 as the first release where “iPhone OS” was renamed “iOS” to acknowledge a second device on one stack. WWDC 2010 sat between the two releases. The sessions that mattered share a single move: patterns developers had been hand-rolling against touchesBegan:, pthread_create, “is the app foregrounded?” booleans, single-screen iPhone layouts, and folk-wisdom method names finally got named primitives in the SDK to replace them.

WWDC 2008 was the year third-party iPhone development became possible. The SDK opened in March, the App Store opened in July, and Apple shipped four design-principle sessions that year that still describe the shape of every iOS app I write in 2026: 312 (the SDK runtime), 348 (the Cocoa philosophy), 940 (Obj-C 2.0 properties and protocols), and 382 (the GCD preview). Three of the four bets paid off in the form they were originally pitched. One had to be rewritten twice before it stuck.

WWDC 2009 was two releases doing different jobs. iPhone OS 3.0 shipped on June 17 and turned the App Store from a curiosity into a viable place to ship a product. Snow Leopard shipped on August 28 with no new user-facing features at all, marketed literally as “0 new features,” because the work that year went into the foundation: a 64-bit rewrite of every Mac framework, the Clang toolchain replacing GCC, and blocks plus Grand Central Dispatch. The two releases ship eleven weeks apart, in different keynotes, and are usually remembered separately. Reading them together is the only honest way to look at 2009, because each release filled a gap the other left.

Every concurrency mechanism on Apple platforms, from pthread up to Swift 6.2’s approachable concurrency. Runnable examples and migration paths.

A May 2026 snapshot of every major AI provider, with the eight weeks of releases since the March guide and a deeper look at the platform stacks behind the top providers.

The same trivial algorithm in ten languages, ordered by year of birth. Beyond “syntax differs,” the interesting part is what each language insists you write down: type signatures, memory ownership, package envelopes, entry-point ceremony. The shape of the boilerplate is the language’s taste.

Recipes for the Git situations that come up often enough to forget the exact incantation.