Computation

User interfaces (UIs) are the connections between us — soft, adaptable humans — and the hard, deterministic world of data and machines.

Historically, these interfaces have been rigid, representing the deterministic logic of the machine and relying on the user to translate the hard logic into a soft, meaningful form. With the rise of LLM capabilities, our technology is newly better at acting soft and squishy. Which brings the question: how should our interfaces handle the transition from the hard logic of machines into the soft logic of humans?

...Hopefully this framework of segmenting at different scales or gradually transitioning across different dimensions can help organize our thinking.

[3] Since the early days of computing there has been a shift from being “close to the metal”.

[22] I would like to posit that women, before the mouse and after, were always and already “close to the metal”.

[27] Being close to the metal is all at once a means and a value and a metaphor. It is a means of getting into the hardware, being able to get into the chip and understand its switches before layers of abstraction start to cover its mechanics.

[28] ...If you are close to the metal, then you are a programmer in the truest form.

Do you dream about your smartphone?
Does it feel like a place that you can inhabit and shape and reconfigure?
Does it give you a sense of possibility?

Computers are a feeling, not a device.

The agenda is to expand our understanding of what makes the computer-feeling.
The agenda is to advance the computer-feeling in devices, objects, and cultures.

The pipeline that transforms three.js code to pixels looks like this:

1. three.js JavaScript code is executed on the CPU
2. Shader code is executed on the GPU
3. Pixels are rendered on the screen

A shader has two parts, a vertex and fragment shader. They work like this:

1. Each vertex runs through the vertex shader to get its viewport space position.
2. Primitives are converted into fragments. Fragments are data corresponding to a potential pixel.
3. Each fragment runs through the fragment shader to get its color.

The representation of a task can radically affect our reasoning abilities and performance. For example, the game of tic-tac-toe (opposing players mark X's and O's in a 3x3 grid) can be equivalently represented as a game of drawing numbered cards with the goal of selecting three that sum to 15. From a computational perspective, these two problems are isomorphic. However, the tic-tac-toe representation is significantly easier to work with because the representational form of the problem makes visible the most relevant constraints implicit in the problem. As Simon writes, in mathematics, "solving a problem simply means representing a problem so as to make the solution transparent"

It’s worth mentioning that in some extreme situations it’s not the internal structure of the observer that makes perceived time stop; instead it’s the underlying structure of the universe itself. As we’ve mentioned, the “progress of the universe” is associated with successive rewriting of the underlying hypergraph. But when there’s been “too much activity in the hypergraph” (which physically corresponds roughly to too much energy-momentum), one can end up with a situation in which “there are no more rewrites that can be done”—so that in effect some part of the universe can no longer progress, and “time stops” there. It’s analogous to what happens at a spacelike singularity (normally associated with a black hole) in traditional general relativity. But now it has a very direct computational interpretation: one’s reached a “fixed point” at which there’s no more computation to do. And so there’s no progress to make in time.

No winners, no losers, and no end — the Game of Life, also known simply as Life, is no ordinary computer game. Created by British mathematician John Horton Conway in 1970, Life debuted in Scientific American, where it was hailed as the key to a new area of mathematical research, the field of cellular automata. Less of a game than a demonstration of logical possibilities, Life is based on simple rules and produces patterns of light and dark on computer screens that reflect the unpredictability, complexity, and beauty of the universe.

This fascinating popular science journey explores Life's relationship to concepts in information theory, explaining the application of natural law to random systems and demonstrating the necessity of limits. Other topics include the paradox of complexity, Maxwell's demon, Big Bang theory, and much more.

People count by tens and machines count by twos—that pretty much sums up the way we do arithmetic on this planet. But there are countless other ways to count. Here I want to offer three cheers for base 3, the ternary system. The numerals in this sequence—beginning 0, 1, 2, 10, 11, 12, 20, 21, 22, 100, 101—are not as widely known or widely used as their decimal and binary cousins, but they have charms all their own. They are the Goldilocks choice among numbering systems: When base 2 is too small and base 10 is too big, base 3 is just right.

...The cultural preference for base 10 and the engineering advantages of base 2 have nothing to do with any intrinsic properties of the decimal and binary numbering systems. Base 3, on the other hand, does have a genuine mathematical distinction in its favor. By one plausible measure, it is the most efficient of all integer bases; it offers the most economical way of representing numbers.

The constant pursuit of human centric qualia further distances us from the innate elemental properties on which computation relies — computation is not an extension of nature but rather part of nature itself. We can deliberately engage with the strategic metaphors that serve to legitimize abstract techno landscapes and their inhabitants: The cloud, internet of things, and the desktop utilize our understanding of the physical world to ground us in familiarity, but without consequence. Might we instead choose to reshape, tend to, and explore the shared grounds between nature and technology as an ongoing process, allowing metaphors to sit in a state of perplexity to allow collaborative authorship by human, non-human, and environment, rather than consolidated authorship of a few? 

By tracing the personal and earthly genealogy of computers and their predecessors, we can redefine and reconstitute their fundamental material properties based on discoveries made in the world around us — building hardware like earthenware

A Small Matter of Programming asks why it has been so difficult for end users to command programming power and explores the problems of end user-driven application development that must be solved to afford end users greater computational power. Drawing on empirical research on existing end user systems, A Small Matter of Programming analyzes cognitive, social, and technical issues of end user programming. In particular, it examines the importance of task-specific programming languages, visual application frameworks, and collaborative work practices for end user computing, with the goal of helping designers and programmers understand and better satisfy the needs of end users who want the capability to create, customize, and extend their applications software.

The principle of “good enough”  is a rule in software and hardware. It indicates that consumers will use products that are good enough for their requirements, despite the availability of more advanced technology.

I've been thinking about this idea a lot lately. In fact, I've had the beginning of a blog post titled “Just Because You Can Doesn't Mean You Should” sitting in my ideas folder for several weeks now. Just because you can afford the fanciest, most powerful device doesn't mean you should buy it. I fall into this trap myself from time to time, and this is a good reminder for all of us not to get caught up in it. “Good enough” truly is good enough despite the availability of more powerful technology.

An ex-Apple interface designer’s 40-year plan to redesign not just the way we use computers, but the way we think with them.

The Busy Beaver function grows faster than any function that can be computed, and we know that because if a systematic method existed to compute arbitrary BB(n) values, then we could use that method to determine whether a given Turing machine halts (if the machine has n states, just check whether it runs for more than BB(n) steps; if it does, it must run forever). This is the famous halting problem, which Turing proved to be unsolvable by finite means. The Busy Beaver function is Turing-uncomputability made flesh, a finite function that scrapes the edge of infinity.

Andy and Bill's law is a statement that new software will always consume any increase in computing power that new hardware can provide.

On two occasions, I have been asked, 'Pray, Mr. Babbage, if you put into the machine wrong figures, will the right answers come out?' I am not able to rightly apprehend the kind of confusion of ideas that could provoke such a question.

Interpretability techniques are normally studied in isolation.
We explore the powerful interfaces that arise when you combine them — 
and the rich structure of this combinatorial space.