Tag: computing

Posted on by

Ancient Web: Millitext Squeezed Letters Into LCD Subpixels

Millitext asks a wonderfully unnecessary question: how small can readable text on a computer monitor get before it becomes basically a secret message?

Visit the Millitext experiment

Matt Sarnoff published the project in 2008. The trick is not a tiny font in the normal sense. It abuses the physical construction of an LCD panel.

A conventional pixel is made from red, green, and blue subpixels. Normally those three elements work together to produce one perceived color. Millitext instead treats the subpixels as individual columns, effectively tripling the horizontal drawing resolution available for extremely small letterforms.

The result is text only a couple of millimeters tall.

On the right kind of LCD, you can sometimes read it by getting uncomfortably close to the screen. Otherwise Sarnoff recommends a magnifying glass or a digital camera in macro mode.

Typography at the hardware boundary

The fun part is that Millitext depends on assumptions modern software usually tries to hide from you.

It cares about the exact ordering of physical red, green, and blue elements in the panel. It will not work correctly on a CRT because a CRT does not have the same regular LCD subpixel grid. It can also display incorrectly on LCDs whose subpixel order differs from the arrangement the image expects.

In other words, this tiny text is not just an image.

It is an image designed for the physical geometry of one class of display hardware.

That makes the project a neat little fossil from an era when LCD subpixel rendering was becoming familiar to ordinary computer users through technologies like ClearType, but screens were still crude enough that people could think about their pixel structure directly.

Sarnoff is careful not to claim he invented subpixel rendering. His page says the idea had existed for years and that the project came from experimenting with whether subpixels could be used directly to encode tiny text.

That restraint makes the experiment better.

It is not pretending to be a revolution. It is somebody noticing a technical property of the hardware and pushing it until the screen starts doing something ridiculous.

The generator lets visitors enter text, choose a font, adjust brightness, invert colors, and create their own microscopic messages. The page is still understandable because it explains the phenomenon immediately instead of burying it under an interactive demo with no context.

CacheRat’s 1,967 Ancient Web Domains research list keeps finding experiments like this because the old Web had a healthy supply of people building a whole page around one clever observation.

Sometimes that observation was: technically, every pixel contains three smaller pixels, so let’s make the letters even tinier.

Try Millitext

Posted on by

Ancient Web: MS Word Sucks Turned Software Frustration Into a Manifesto

Before software complaints became app-store reviews, angry tweets, and one-star screenshots, somebody had to buy a domain, write several thousand words, and explain exactly why the program deserved to be thrown into the sea.

Read MS Word Sucks

The page known as MS Word Sucks is a fine specimen of that older Internet tradition. It is not a tidy product review. It is a sustained grievance against Microsoft Word, written with the energy of someone who has been interrupted by AutoCorrect one time too many.

By 2004 the essay was circulating widely enough to become the subject of a Slashdot discussion, where readers quoted some of its more volcanic passages and immediately began arguing about Word, OpenOffice, LaTeX, document formats, user interfaces, and whether the author’s suffering was self-inflicted.

That reaction is almost as historically useful as the rant itself.

Software used to inspire manifestos

The complaints are recognizable even now: unwanted formatting, preferences that refuse to stay put, automatic features that feel less like assistance than sabotage, document behavior the user did not request, and the suspicion that increasingly complicated software had stopped serving the person sitting in front of it.

What makes the page feel old is not the subject. People still hate software.

It is the form.

A frustrated user did not need to compress the complaint into 280 characters or optimize it for a video. He could publish a plain HTML page, swear at Microsoft for as long as necessary, and leave it sitting on the public Web where search engines, mailing lists, forums, and friends would eventually find it.

The Web was full of pages like this: personal essays that were too opinionated for documentation, too specific for journalism, and too long for anyone except the author and the exact stranger who desperately needed to know that somebody else had noticed the same stupid behavior.

That is why these pages matter as artifacts. They preserve the emotional history of computing, not merely the release history.

Microsoft Word can be documented through version numbers, file formats, screenshots, and feature lists. A rant tells you what using the software felt like to at least one technically literate person while those design decisions were still current annoyances rather than historical curiosities.

CacheRat’s 1,967 Ancient Web Domains research list includes pages like this because old software culture was partly built from documentation and partly built from people yelling at the documentation.

Sometimes the rant ages badly.

Sometimes, twenty years later, you read it and immediately recognize the exact argument.

Revisit the original MS Word Sucks page

Posted on by

Ancient Web: Game Zero Builds a 4-Bit Processor One Logic Gate at a Time

Game Zero’s old processor-design tutorial starts with a dangerous educational idea: instead of telling you what a CPU does, build one small enough to understand.

Visit The Math Behind the Magic

The tutorial works upward from basic digital logic toward a four-bit processor. Half adders become larger arithmetic blocks. Incrementers manipulate binary values. Registers and buffers introduce storage and control. RAM, ROM, buses, and an accumulator eventually turn a pile of schematic pieces into something recognizable as a processor.

It is primitive by modern CPU standards.

That is exactly why it works.

Four bits is enough to expose the machinery

A contemporary processor hides staggering complexity behind layers of abstraction. Game Zero strips nearly all of that away.

The reader sees why a half adder is useful, how several small components can become a four-bit incrementer, and how a register changes a circuit from purely combinational logic into something that can remember a previous state.

The memory section distinguishes RAM, ROM, and output devices and places them on a shared data bus. A special register beside the arithmetic logic unit becomes the accumulator. The text then walks through what happens when data moves through the machine.

The diagrams matter as much as the prose. Small circuits are repeatedly wrapped into simpler boxes so later schematics remain readable. That is not only electronics instruction; it is abstraction being demonstrated in real time.

The pages also preserve their rough edges. Some diagrams are missing. Some text is unfinished. One section literally announces that an update is in progress.

That incompleteness makes the site feel like a workshop notebook instead of a polished textbook product.

CacheRat’s 1,967 Ancient Web Domains research list includes technical tutorials like this because the web used to contain a remarkable number of people patiently unpacking machinery that commercial documentation assumed you would never need to understand.

Four bits is not much computer.

It is enough computer to see the trick.

Return to The Math Behind the Magic

Posted on by

Ancient Web: Yarchive Saved Usenet Technical Knowledge Before It Scrolled Away

Before forums became websites and websites became platforms, an enormous amount of practical knowledge simply scrolled through Usenet.

Visit Yarchive

Yarchive is Norman Yarvin’s curated collection of Usenet material organized by subject rather than by newsgroup chronology.

The front page breaks the archive into categories including air conditioning, aircraft, bicycles, cars, chemistry, computers, electronics, food, houses, metalworking, telephones, physics, space, environmental topics, security, and other technical subjects.

That organization is the whole point.

Saving the useful parts of a conversation stream

Usenet was good at conversation and bad at permanence.

A useful explanation might appear in the middle of a long thread, be copied into another discussion, disappear from a local news server, and eventually become difficult to locate even if somebody remembered that it existed.

Yarchive takes a different approach.

Instead of trying to preserve everything equally, it collects posts judged worth keeping and groups them by topic. The result feels closer to a reference notebook than a message-board backup.

That matters because old technical discussions often contain the practical details formal documentation skips.

A manual explains what a device should do. A working engineer on Usenet may explain why a failure appears only when the weather changes, which replacement part behaves differently, what measurement is misleading, or why a commonly repeated explanation is wrong.

The archive’s update history stretches from the early 2000s into 2011, preserving a layer of Internet knowledge that originated even earlier.

It also represents an old editorial philosophy: a human reader could extract durable knowledge from a noisy public conversation and publish the useful pieces as static HTML.

CacheRat’s 1,967 Ancient Web Domains research list contains many examples of people manually turning network culture into reference works.

Yarchive did it with Usenet before the modern web rediscovered the idea of “community knowledge.”

Return to Yarchive