Tag: programming

Posted on by

Ancient Web: Davar Grew a Personal Reference Library Instead of Building a Website

Davar.net is what happens when a programmer treats a website less like a publication and more like a workbench. Started in 1997, it accumulated programming notes, Go rules, Zen material, quotations, Russian writing, mainframe references, UNIX information, humor, mathematics and whatever else its creator considered worth organizing.

Visit the Davar Web Site

The site’s own explanation is better than any modern content-strategy language. Its creator says Davar is not really being “constructed.” It is being grown. New branches and leaves appear as useful material accumulates, and completion is not the point.

That philosophy is visible in the navigation. The homepage still lists dated sections such as Zen from 1997, Computer Science from 1998, Go from 1998, Mainframe material from 1998, UNIX from 2001 and a large site index. There is even a link to download the entire site.

It also proudly says it was developed with Netscape for a minimum 800×600 display. Nobody hired a conversion optimization consultant to workshop that sentence.

What makes Davar interesting now is not any single subject. It is the architecture of the whole thing. A personal website could once serve as an external memory system: collect code snippets, reading notes, FAQs, quotations, game rules and literature in one place, then expose that private organizational structure to anyone else who found it useful.

The Go section alone includes basic rules, additional rules, ko fights, territory explanations, problems, glossaries, coordinate systems and graphical elements. Elsewhere are COBOL patterns, CList material, PowerBASIC routines, UNIX notes and old Internet references. It is difficult to imagine a modern commercial site intentionally combining Zen, MQSeries commands and Russian fiction under one navigation bar. That is precisely why personal sites were good.

There is also a practical lesson for modern webmasters. Davar’s information architecture is plain, but it is legible. Sections are dated. The site index is exhaustive. Pages have specific purposes. Twenty-eight years of software fashion came and went while ordinary links continued doing their job.

That sort of durable weirdness is why CacheRat keeps the larger 1,967 Ancient Web Domains research list. The old Web was full of people organizing knowledge according to their own brains instead of a platform template.

Davar is still worth exploring precisely because it never tried to become a coherent media property. It remained one person’s growing reference shelf.

Explore Davar.net

Posted on by

Ancient Web: The First Church of Grady Booch Made Object-Oriented Design a Religion

In 1997, somebody looked at the increasingly serious world of object-oriented software design and decided what it really needed was a church. The resulting First Church of Grady Booch is still online, still speaking in inheritance hierarchies, and still treating software methodology with exactly the amount of reverence programmers tend to deserve.

Read the Booch Bible

The joke works because Grady Booch was not an obscure name. Booch was one of the major figures in object-oriented analysis and design, and in the mid-1990s he worked with Jim Rumbaugh and Ivar Jacobson on the effort that became the Unified Modeling Language. UML was an attempt to bring order to a period when competing object-modeling systems had multiplied into what the Object Management Group itself describes as the “method wars.”

The Church takes that seriousness and runs it through the class hierarchy.

Its front page explains that the church is itself an object. It inherits from Grady Booch, becomes a superclass of the people, and occupies a church building that is a subclass of Religious Structure, which is a subclass of Building. The joke is not merely “programming is a religion.” It is written in the actual conceptual vocabulary that object-oriented programmers were spending their working lives thinking about.

The linked Booch Bible extends the bit into scripture. That makes the site a small but unusually clean fossil of 1990s programmer culture: people building a public joke for other people who would immediately understand terms such as classes, inheritance and object models without needing a glossary or a platform algorithm to deliver it to them.

There is also a useful historical accident here. The Church says it was founded in 1997, the same period when UML was becoming a formal standard. The parody therefore survives beside the technology it was parodying. Modern developers can read polished histories of UML anywhere; this page shows what programmers were joking about while that history was still happening.

For a webmaster, the site is another reminder that a tiny joke can outlive entire generations of frameworks if its dependencies are basically “HTML and a domain name.”

CacheRat’s larger 1,967 Ancient Web Domains research list contains many sites like this: not necessarily historically important on their own, but excellent evidence of how people actually used the Web.

The First Church remains online, and its sacred text remains mercifully shorter than most enterprise architecture documentation.

Return to the Booch Bible

Posted on by

Ancient Web: Greg Woods Built the Kind of UNIX Homepage That Never Really Ends

Greg A. Woods’s homepage is what a technical personal website looks like when nobody periodically arrives with a branding deck and orders the interesting parts removed.

Visit Greg A. Woods’s homepage

Woods describes himself through a long history of systems programming, UNIX work, consulting, and involvement with technical communities including USENIX and UNIX Unanimous. The page does not compress that history into a neat biography. Instead, it branches outward into years of software, arguments, reference tables, hardware notes, and strong opinions about how computers should behave.

There are pages about C programming, Git, Multics, Rdist, Smalltalk and Squeak, serial connectors, subnetting, old computers, public-key cryptography, spam, software distribution, and assorted utilities.

There are also pages with titles that do not pretend neutrality.

“SuDo is BAD.”

“SPF is BAD.”

Elsewhere Woods argues about tabs, dynamic linking, programming practices, and systems administration with the confidence of somebody who has already had the same argument on several mailing lists and is now giving the Web a permanent copy.

That is part of the site’s historical value.

Technical culture used to leave fingerprints

Modern technical documentation tends to split into official manuals, issue trackers, Stack Overflow answers, social posts, repositories, and ephemeral chat rooms. Personal context gets separated from technical content.

Older homepages often mixed all of it.

Woods’s old-computer material, for example, lists systems he owned or worked with, including PDP-11 hardware and AT&T 3B2 machines. Some entries acknowledge a less romantic side of collecting: equipment deteriorated, storage situations changed, and not everything survived.

The software pages similarly preserve more than code. They preserve a working programmer’s priorities. Which problems annoyed him enough to document? Which tools deserved maintenance? Which industry conventions deserved an essay explaining why they were wrong?

Even the page furniture matters.

The site rejects browser-specific design, quotes Tim Berners-Lee on universal access, carries old-style construction graphics and personal badges, and remains intentionally independent of the visual conventions that replaced the homepage era. The current page has continued to receive updates rather than being sealed as a museum reconstruction.

That continuity makes the site especially useful. The ancient and current layers occupy the same namespace.

A reader can move from old UNIX culture into newer Git notes without crossing a corporate migration boundary or discovering that the first fifteen years were deleted during a redesign.

CacheRat’s 1,967 Ancient Web Domains research list includes pages like this because technical history is not only preserved in standards documents and source trees. It survives in the stubborn personal pages where practitioners explained what they thought the standards documents got wrong.

Those arguments are part of the record too.

Explore Greg Woods’s UNIX-heavy personal Web

Posted on by

Ancient Web: The Internet Pizza Server Was Serving Fake Pizza in 1994

In 1994, while businesses were beginning to figure out how to sell things on the Web, a group of people built a server that would let you order a pizza that did not exist.

Order something from the Internet Pizza Server

The Internet Pizza Server is one of those early-Web projects that makes much more sense once you stop asking what problem it solved.

Brian “Beej” Hall’s history of the project says the idea began around 1993 as a text-based email service. A dedicated account was secured that October, and the group wrote software that could receive an order and generate an image of a pizza with the requested toppings.

The service officially went online in April 1994.

Then the Web arrived and somebody quite reasonably decided that a fake pizza generator needed an HTML form.

The toppings are where professionalism ended

The surviving ordering page lets users choose normal ingredients such as pepperoni and mushrooms alongside eyeballs, goblins, kittens, baseballs, hammers, road signs, sinks, and other ingredients unlikely to pass a restaurant health inspection.

The underlying system was real software.

The original pizza-generation engine was written in C and assembled pizzas as Portable PixMap images before converting them into GIF or JPEG output. The site documents the mail-filtering code, MIME support, graphics conversion tools, and later rewrites that replaced the original monolithic program with a faster modular renderer.

That mixture is pure early Internet: legitimate systems programming in service of something completely unnecessary.

The server also preserves the attitude of the period. In September 1994 its operators posted a “Declaration of War” aimed at Pizza Hut’s new online presence, arguing that the Internet’s tradition of free services was being invaded by commercial interests.

The joke is obvious, but the tension was real.

A network built largely around universities, research institutions, hobbyists, public services, mailing lists, and volunteer projects was becoming a commercial medium very quickly. The Pizza Server sat on the silly side of that transition and was self-aware enough to comment on it while rendering digital pepperoni.

The project survived long enough to accumulate press mentions, technical documentation, a gift shop, related services, and even a Core War King-of-the-Hill server.

In 2026, generating a picture from a form input is trivial. In 1994, wiring email, C programs, image conversion, MIME, and Web forms together into an interactive public service was experimentation.

The fact that the experiment produced fake pizza instead of quarterly revenue projections is a feature.

CacheRat’s 1,967 Ancient Web Domains research list includes artifacts like this because the early Web was not only a collection of pages. It was a culture of people connecting tools together just to see what happened.

Sometimes what happened was a pizza with kittens and a hammer on it.

Visit the Internet Pizza Server

Posted on by

Ancient Web: Big Ball of Mud Named the Architecture Everybody Pretends Not to Build

Software architecture diagrams are usually neat because nobody puts the emergency shell script, duplicate database, one terrifying global variable, and the service Bob wrote in 2017 but nobody is allowed to restart on the diagram.

Read Big Ball of Mud

Brian Foote and Joseph Yoder gave that other architecture a name: Big Ball of Mud.

The paper grew out of the software-patterns community in the 1990s and was presented in connection with PLoP ’97. Its central observation was uncomfortable precisely because it was obvious: the most common software architecture was not the carefully layered, elegantly decoupled system celebrated in books and conference talks.

It was the sprawling one.

The authors describe a Big Ball of Mud as a haphazardly structured system shaped by expedient repair, piecemeal growth, shared information, duplicated knowledge, and code that survives because changing it cleanly is harder than adding one more patch.

The site still preserves the paper, related presentations, and later commentary around it.

Bad architecture can still be successful software

The interesting part of the essay is that it does not simply shout “bad programmer” and go home.

Foote and Yoder examine why these systems appear.

They discuss patterns such as Throwaway Code that was never actually thrown away and Piecemeal Growth where useful systems expand one local decision at a time. A prototype succeeds. Somebody adds a feature. Then another. Customers depend on it. Deadlines become real. The temporary structure acquires a payroll department.

That is a much more useful explanation than pretending every ugly codebase was produced by people who had never heard of abstraction.

The paper also asks why there is such a large gap between the architecture software engineers say they value and the architecture that is routinely deployed.

That question has aged remarkably well.

Modern stacks have containers, cloud orchestration, service meshes, event buses, generated clients, twelve flavors of observability, and enough YAML to wallpaper a municipal building. None of those technologies abolish deadline pressure, organizational boundaries, legacy dependencies, or the human tendency to make the smallest change likely to survive Friday.

The vocabulary changed. The mud remains damp.

The site is useful in 2026 not just because the essay became influential, but because the original Web presentation remains surrounded by the intellectual neighborhood that produced it: related papers, talks, archives, and Brian Foote’s later reflections on why the idea kept resonating.

CacheRat’s 1,967 Ancient Web Domains research list includes pages like this because some old websites preserve the moment a useful idea acquired the words everybody still uses for it.

Your architecture diagram may say “platform.”

The repository knows what it is.

Enter the Big Ball of Mud

Posted on by

Ancient Web: Canadian Mind Products Is a Java Reference Library Attached to an Entire Worldview

Canadian Mind Products is what happens when a programmer decides a website does not need to pick one subject, one tone, or even one reason to exist.

Visit Canadian Mind Products

Roedy Green’s site describes one of its goals as teaching people to use computers effectively, particularly the Java language. Around that technical core grew a sprawling collection of downloads, hardware notes, Java material, applets, environmental writing, ethics, Esperanto, quotations, essays, and personal argument.

The navigation feels less like a publication than a map of one person’s brain.

The Java part alone is a web artifact

Canadian Mind Products became especially well known for its Java material. The site still exposes a Java section alongside downloads, hardware references, applets, site maps, and old utilities. It also built tools for mirroring the website locally, including a “Replicator” system whose documentation explicitly discusses keeping a copy in case the site ever disappears.

That preservation instinct feels almost prophetic now.

The broader site is much stranger than a programming reference. Technical pages sit beside environmental advocacy, politics, religion, human rights, money, relationships, and long personal quotations. There is no editorial effort to make those categories feel like one clean brand.

That is precisely why it belongs to the older web.

A personal website could be a technical manual in one directory, an argument in the next, a software archive somewhere else, and a running notebook everywhere in between. Search engines indexed the pages individually, so the whole site did not have to fit into one marketable identity.

The result can be abrasive, useful, obsessive, outdated, insightful, or all five within a few clicks.

What matters historically is the shape of it: one person accumulating knowledge in public over years, without flattening it into a content strategy.

CacheRat’s 1,967 Ancient Web Domains research list contains many personal sites where the useful material is inseparable from the personality that organized it.

Canadian Mind Products may be one of the purest examples.

It is not tidy.

Neither was the web.

Return to Canadian Mind Products

Posted on by

Ancient Web: A86 Is Still Selling an x86 Assembler From the DOS Era

A86 is the kind of software product page that assumes the visitor already knows what a .COM file is and considers that perfectly reasonable.

Visit the A86/A386 and D86/D386 site

Eric Isaacson’s A86 assembler and D86 debugger belong to the DOS programming world, but the website still preserves the full ecosystem around them: downloads, documentation, feature lists, source libraries, pricing, licensing, Win32 examples, and the 32-bit A386 and D386 versions.

Version 4.05 of A86 can generate DOS .COM files directly, create .OBJ files for a linker, or produce raw object output suitable for ROMs. D86 is a screen-oriented debugger that freezes a program’s state so registers, flags and memory can be inspected while execution is stepped instruction by instruction.

The 32-bit A386 material stretches across the x86 family from the original 8088 through Intel’s Pentium III and AMD’s Athlon, including MMX, SIMD and 3DNow instructions.

The commercial shareware web never completely vanished

The page is fascinating because it still behaves like a software storefront from another computing era.

There is a combined A86/D86 ZIP download. Registered users can buy a library containing more than 200 procedures and macros plus source for roughly 200 short programs. A Win32 package includes a complete HELLO32 example for building programs that run under Windows NT, Windows 95 and later systems.

The language of the page is wonderfully direct. Isaacson calls A86 the finest assembler available and then immediately tells you exactly what it outputs, what processors it understands, and what the debugger does.

No animated product tour is required.

For programmers studying DOS software, old PC development workflows, assembly-language tooling or the transition from 16-bit to 32-bit Windows, the site is more useful now than an abandoned product brochure would be because the actual binaries and technical explanations remain connected.

CacheRat’s 1,967 Ancient Web Domains research list contains many surviving software pages where the product itself became historical evidence.

A86 is one of the better examples.

The web page still expects somebody might show up wanting to assemble some x86 code.

Return to the A86 site

Posted on by

Ancient Web: Linus Akesson Built the Kind of Homepage the Web Needs

Linus Åkesson’s homepage is what happens when a personal website is allowed to remain a personal website for years instead of being converted into a brand funnel. There is code, music, hardware, poetry, old computers and whatever else happened to become interesting.

Visit linusakesson.net

Åkesson, also known in the demoscene as lft, is a Swedish software engineer whose site functions as homepage, blog, documentation archive and download server. Its navigation is almost a manifesto by accident: chip music, hardware projects, games, obfuscated programming, C64 material, interactive fiction, software downloads and scene productions all sit beside one another because one person made all of them.

In other words, categories follow curiosity rather than a content strategy.

Machines that make music and software that fits where it shouldn’t

The featured projects include custom electronic instruments such as the Chipophone and Commodordion, Commodore 64 experiments, microcontroller music, programming techniques and demoscene productions. An early Linux 4K intro placed second at DreamHack Winter 2004. Elsewhere the site documents Dialog, Åkesson’s programming language for interactive fiction, along with the standard library used to build old-school text adventures.

The writing often goes deep enough to become reference material. Instead of merely showing that a project exists, Åkesson explains the trick, posts executable files, documents hardware and leaves the intermediate thinking available for other technical people to inspect.

That is one of the old Web’s best habits.

The important part: it never stopped

The site is not preserved behind glass. It was still publishing new pages in 2026, including C64 demos and performances at 8-bit music events. A homepage that started in the era of personal publishing remains personal while the surrounding Web has changed several times over.

For webmasters, there is a useful lesson here. A site can earn durable search traffic without flattening itself into one subject if the individual pages are specific, well linked and genuinely worth finding. Personality does not have to be removed for information architecture to work.

Linus’s site is one of the hand-built technical corners collected in CacheRat’s 1,967 Ancient Web Domains research list. The full list has many more places where somebody’s interests became an archive almost by accident.

A random-page button is still included in the navigation. More websites should have one.

Go wander through linusakesson.net