Yehuda Katz wycats

Temporal Blindness + Clock-Sure Confidence Pattern

For Mauricio's code generator work

The Problem

LLMs experience time like colorblindness - systematically wrong but feeling certain. Claude confidently says "last month" when it was 6 months ago, or "just discussed" when it was 3 conversations back.

The Framework as Opt-Out: How Complexity Theories Enable Antisocial Engineering

The Pattern

Grand theories of software complexity (Simple Made Easy, Out of the Tarpit) create intellectual frameworks that let their adherents opt out of shared solutions while feeling superior about it.

The mechanism:

Create a taxonomy - Simple vs Easy, Essential vs Accidental

Ember's new GJS syntax is now supported by GitHub!

GJS

A boring component:

class ActionButton extends Component {
  <template>

Starbeam Renderers

Framework	Renderer Status	Spec Compatibility
React	released	next release
Preact	released	next release
Vue	next release	next release
Svelte	designing	-
Ember	designing	-
Solid	roadmap	-

Getter-Only Auto-Accessor Decorators

Broadly speaking, the idea is that you should be able to create an accessor decorator that doesn't expose a setter.

I think the most natural way to express this is for the set function returned by an accessor decorator to have a never return type. The idea is that such a decorator would result in the type system treating the resulting field as if it was a manually written getter without a setter.

Here's an example scenario:

import { Friend } from "hypothetical-lib";

October 25, 2022 to November 4, 2022

Generics around missingness

function Name<S extends string | undefined>(name: S): S {
  return name;
}

Making `unique-id` a importable function

The Use Cases

import { uniqueId } from "@ember/???";

<template>
  {{#let (unique-id) as |id|}}

Factories

A factory is a function that returns a new reactive object.

Reactive Factories return reactive objects.
Resource Factories also return reactive objects, but they also register cleanup functions that are called when the object is no longer needed.

You can use a class as a factory, but it's not required. When you use a class as a factory, its constructor must take zero required arguments.

	import { CachedFormula, Cell, Formula } from "@starbeam-lite/core";
	import { EventRecorder, TestScheduler } from "@workspace/test-utils";
	import { describe, expect, it } from "vitest";
	import { subscribe } from "../src/subtle";
	import { TAG } from "@starbeam-lite/shared";

	describe("subscribe", () => {
	describe("equivalent to Signal.subtle.Watcher (ported tests)", () => {
	it("should work", () => {
	const events = new EventRecorder();

	{
	"public": true
	}