Luminoid's Site

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.

A short working reference for the Hexo + NexT setup that powers this blog.

The 2021 Node stack was Node + npm + nvm and a third-party tool for everything else. By 2026 every layer has a serious challenger, and Node itself absorbed half of what used to be a separate dependency: test runner, watch mode, dotenv, native TypeScript. This is the snapshot of what to pick and why.