Artickle An Ideotope Appliance

Here are a few notes, barely organized, about Artickle, the system I've cobbled together to realize the “Postclassicism” ideotope.

What is Artickle?

It's a collection of HTML and CSS markup and ECMAScript code (the technology, or "cool stuff"), plus the actual material on postclassicism (the content, or "afterthought"). It presents a web page that looks odd and does strange things when you poke at it. At least it does if you happen to view it with Firefox 3. This is a prototype; it's not meant to be browser-independent.

The CSS is designed to organize short fragments of text into a number of small, fixed-position boxes. The boxes are arranged on screen with the largest and most prominent in the center, and the rest radiating out from it in rough concentric elipses. Boxes further from the center are smaller and closer in color to the background.

The content is straight HTML, but with a somewhat odd structure and markup. The content is flattened - the body consists of a series of divisions, one for each text fragment. Fragments have little internal structure. They may be marked up for typography. They do have some internal structure, discussed below.

The scripts make things happen on mouseover and click. Part of the design philosophy is to avoid explaining those things in any great detail.

What's with that name?

"Artickle" is a portmanteau of "article" and "tickle". It's meant as an alternative to the scholarly article, with ticklish affordances. It tickles the reader with bits and pieces of information; it responds when tickled back.

The name "artickle" (especially when pronounced out loud in the proper fashion, as "ar-tickle") is awkward — deliberately so. This is an awkward application because it's an unfinished prototype; it's an awkward interface by design, because it's meant to reveal, rather than suture over, the awkward groping and stumbling of reading intellectually demanding texts. And Artickle wants to call attention to itself, to interrupt, to disrupt.

Against ease

Most of our software tools are designed to be consistent — and when they fail at that, it's a flaw (one frequently demonstrated by much commercial end-user software). Consistency is important for many reasons, one of which is to streamline repetitive tasks. That's why user interfaces have keyboard accelerators, shells have pipelines, and programming languages have iterators. When repetitive tasks become onerous or obtrusive, they interrupt our workflow and reduce our productivity, not to mention our enjoyment.

But there are areas of endeavor where automating repetition can be counterproductive — where even consistency itself may not be desirable. Invention, in the rhetorical sense, is one. There are invention strategies which are repetitive, but it is the very act of repetition which is valuable in them; automating it would render the strategy meaningless. And consistency is the enemy of invention. Invention seeks to increase information entropy, which can be defined as surprise.

Artickle is a reading tool, not one for writing (currently; I have ideas about extending it for composition). And invention is usually associated with the production of text rather than its reception. But reading scholarly work, at least theoretical work, is inherently an inventive act. We don't read theory to acquire facts; we read it to push our own intellectual processes into new configurations. Reading theory is reading as intellectual work.

Artickle takes up the ideas of Herbert Spencer and Richard Lanham on attention: the reader's attention is a limited resource. Besides being a marker of information production, surprise — inconsistency, the unexpected, alteration — appeals to attention. Artickle tries to practice a tactical inconsistency. It incorporates (pseudo-) randomness and dynamic rearrangement. It demands reader interaction, not simply reception.

Theoretical writing has always been torn between, on the one hand, a will to complexity (complex ideas, complex arguments, complex sentence structures), and on the other a love (even if often not fully realized) of the possibilities of the written word. The former produces difficulty, the latter aims toward the seductive ease of smooth and compelling prose. There's much to be said in favor of trying to produce theory that strives toward the latter, of writing readable theory. Artickle, however, is something of an experiment in the other direction. It tries to make theory pop. It wants to provoke.

If the web's Platonic model is Bush's memex, Artickle's is the pile of papers with hastely-scrawled notes piled on every available surface that I'm left with when I write an article.

Design notes

As described above, Artickle is composed of three pieces: HTML content, CSS styling, and scripts.

The HTML is structured as fragments, small pieces of text. Fragments exist in parallel, with no HTML hierarchic relationships between them.

The CSS style rules exist in an external stylesheet. They use generic class names that refer to a fragment's current position on the page, so they're not tied to particular content.

The scripts are also entirely implemented as an external script file, with no relationship to any specific content. The scripts provide the dynamic document transformations and interaction that make Artickle usable, but they're also responsible for behind-the-scenes processing of metadata. They maintain a dynamic model of the semantic relationships among the fragments (as specified by the author) and help the reader navigate along those relationships.

The scripts are written in ECMAScript (of which JavaScript is Mozilla's implementation). My intent is to use only standard ECMAScript, but I haven't checked the code for deviations.

Because the Artickle styling and scripts are independent of the content, it's theoretically possible to write other Artickle documents simply by creating the HTML file with the appropriate markup for its fragments. There's no Artickle authoring tool today — I created the Postclassicism content and structure manually. Authoring might someday be built into Artickle itself, with appropriately ticklish controls.


The fragments that make up Artickle content are HTML divisions in a particular, if flexible, form:

When an Artickle document is loaded into the browser, the scripts parse and arrange the fragments. Arrangement involves assigning multiple CSS classes to each fragment (based on which fragment is currently "top", ie in the center of the screen, and then placing other fragments around it). The classes determine the fragment's position on the screen and its size and color.

Normally the "long" and "longer" text in a fragment is not shown. When a fragment is moved to the top (by clicking it), its "long" text is revealed. If the top fragment is clicked, it changes to its extended view, which also shows the "longer" part of the fragment.


Artickle doesn't provide any help for the user, or much prompting. It's like those mouse-driven computer role-playing games that were once so popular: you're supposed to figure it out by playing with it, and the main affordances are moving the mouse cursor and clicking on things.

Mousing over fragments and clicking fragments have effects. There are probably others — what you can do is a function of what I've implemented at the moment, and I'm not likely to update this description very often. Try it and see.