Here is another slow expression to demonstrate the disjunction pruning optimization I talked about earlier.

Suppose you declare a variable of implicitly unwrapped optional type:

var x: Int! = ...

The value of x is stored like an ordinary optional "Int?", but a reference to x from inside an expression is presented as a disjunction---the type of the reference is either "Int", or "Int?". If both lead to a solution, we favor the "Int?" choice; otherwise, we get the "Int" choice, and the compiler then lowers the reference to a runtime check.

Now, consider this expression:

let result = x + x + x + x + x + x

It takes the Swift 6.3 compiler a third of a second to type check this expression, and now its instant with recent main snapshots. What changed?

There are two problems in computer science:

1. We could do this better
2. We should not do this at all

I published a new article, "Introducing the Experimental Styles API in Jetpack Compose".

It introduces the Styles API as a new way to define interactive, stateful Compose UI with automatic animations and efficient style application.

https://doveletter.skydoves.me/preview/articles/compose-styles

When you email issues to Obsidian Entertainment (the video game company) their AI support hallucinates and tells you to email Obsidian (the note-taking company) instead.

The perils of trusting an LLM with your customer support.

The write-up of my new graph layout algorithm for SpiderMonkey is finally live.

We built a custom layout algorithm for JS and WASM that follows the structure of the source code. No more spaghetti nightmares from Graphviz, and thousands of times faster.

https://spidermonkey.dev/blog/2025/10/28/iongraph-web.html

yeeeessss
YEESSSS

more batshit like this

https://bogdanthegeek.github.io/blog/projects/vapeserver/