The promotion of literacy encourages sharing knowledge by writing and reading. That provides the feelings of receiving and giving, a common ebb and flow of life.

Most commodity computers mute people by barricading their labeled buttonboards behind an unlabeled motionbox that must be repetitiously lifted, clunked, and slid with gymnastic precision. Options are what the software developers decided, are without immediate documentation (if any), and are hidden within a cavernous maze of non-personalized menus.

Personal expression and communication become possible with the ubiquitous skill of writing when the commodity software permits the buttonboard to function as a means for recording text. A "personalizable computer" is extensible beyond its default commands and options, as a person fits that within the current flow of events.

Freedom is a side-effect from taking on the responsibility of following through with personal interests. In other words, the experience of pursuing personal interests is the essence of living life, but is perceived externally or by self-reflection as freedom. The pursuit itself is active involvement, hence no absence of responsibility.

Opportunity is sometimes mistaken as freedom, as is the lack of molestation or expectation from other people. Like the fantasies of security and privacy, freedom is never taken away because it is only a perception. At most, freedom is disrupted like the daydream it is.

Blind trust of computer software written by strangers is avoidable, but it requires respecting personal interests and pursuits by saying "no" and being comfortable with the resulting freedom.

Jumping through hoops or over hurdles provides a false sense of accomplishment, a façade of freedom after the labyrinthine escape. Ideally, writing in the computer medium would be without an obstacle course entrance, as immediate as writing on paper.

Unique text editing software often produce unique file types, which make the documents eventually inaccessible when the software is abandoned by its company. Only plain text documents are accessible with any computer, old or new, commodity or personalized.

Plain text files are so versatile that all operating systems and programs are always made from them, although sometimes only the illegible compiled results are ever shared. Filesystems are the bridges between incompatible operating systems, a compatible means of transfering plain text files for reading and editing anywhere.

# notetaking with the computer medium

Paper is one of the best mediums for recording notes. Notes on a sheet of paper can be read by someone else without the need for that person to have a pad of paper.

Notes recorded in the computer medium are undeniably less accessible and less sharable. Computer documents require a computer for reading them, and the computer requires electricity.

A buttonboard with a button for each letter of the alphabet aids in writing legibly and quickly on a computer. However, the casual markings of underlining or thicker lines of text written on paper is typically beyond the limited set of symbols of a buttonboard.

Prose often has parentheses "( )" and square brackets "[ ]" distinguishing supplemental information, or quote marks specifying exact wording. Similarly, the uncommon angle brackets "< >" enclose a name for the kind of mark before its region of typed text.

# the motivation for markup

Whatever is typed is "plain text" when it is compatible with any operating system of any computer, from the past to the present and into the future. No need for converting a document that has plain text markup.

Spacing before and after paragraphs, thicker lines of text, and larger text for headings help demarcate and emphasize ideas. Some text editor programs merge that formatting with the prose in a way that is illegible and uneditable with any other text editor, thereby is no longer plain text.

Instead, consider two approaches: the primary view optimized for editing the text, and a temporary alternate view optimized for perusing. That is, when editing consider marking it when helpful for an alternate read-only view of the document.

Enclose the name of a mark within angle brackets "< >", whereby it is unmistakably distinguishable from the prose while ensuring compatibility as plain text. The alternate read-only view of a document is provided by a program hiding each mark while also modifying the appearance of the following text based on the name of the mark, without modifying the document itself.

Extra software for the alternate view is optional. Reading and editing personal or shared notes remains possible with any text editor on any computer, old or new, commodity or personalized.

# writing and marking plainly

The uncommon angle brackets < and > enclose a name for the kind of mark before its region of text. For example, thicker lines of text is known as "bold" text, therefore the mark is <b>. The region ends similarly with a forward slash "/" in the mark, f.e. </b>.

In other words, a region of text marked at its beginning with <b> would have </b> at its ending. Mnemonically, the "/" then "b" means "end b".

Normally drawn text with <b>this text to be drawn with thicker lines</b> and normally drawn text after it.

Sometimes the ending of a region is obvious by a mark beginning a new region after it, f.e. a paragraph after a paragraph, thereby the ending mark is conveniently optional.

<p>A paragraph of text that is followed by another paragraph.
<p>The previous paragraph obviously ends when this paragraph begins. This one has an ending mark, though it might be unnecessary.</p>

# using HTML for document sources

Hypertext markup language (HTML) is a system of named marks for typed regions of text. The marks evoke imagination of how the text would be drawn or spaced on paper, thereby promoting association and understanding of the content without an alternate view. The alternate view of an HTML document hides each mark and then applies its implied characteristics to its region of text.

For example, notes about some other document will often have the name of that other document for later reference. For computer documents, this more reliably also includes the filename of the document and its location.

The HTML mark for an address is <a> and is supplemented with the href attribute for the "hyperlink reference".

A hyperlink address region of text is underlined and becomes a trigger for viewing its specified document. That makes the alternate view more concise with document addresses, and enhances access to referenced documents.

# organizing and sharing files

A filesystem is a record of locations for documents (files) in a storage device. It tends to also be a source of the modification date and file size, but usually no special feature for comments or descriptions for files.

Commodity operating systems provide their own options for writing descriptions for a file, but those notes are inaccessible with other operating systems. The obvious compatible approach, regardless of operating system or type of filesystem, is consolidating personal descriptions of multiple files into a new document (file).

A document marked with HTML is plain text, therefore always accessible regardless of what computer. Type or copy/paste the document name and optionally mark it as a hyperlink address, perhaps followed by a description. Maybe mark each as a paragraph <p>, or grouped into distinct lists preceded by headings.

In this way, the reason for having each document or image is available, rather than opening each and every document with many different applications and trying to remember later. Documents without descriptions, reasons, or relations to other documents become prime candidates for removal in order to reduce clutter.

Include a framed view of either an HTML document or an image by referencing its source address in the src attribute of an internal frame <iframe>. The view of the document or image is scrollable when larger than the internal frame, which also can have width and height attributes (pixel values).

<iframe src="some-other-document.html"></iframe>
<iframe src="can-be-an-image.jpg" width="400" height="300">
This region is shown instead of the document only when a HTML viewer has no support for the iframe mark.

Or, add an image with the <img> mark and optionally scale it with width or height attributes (pixel values). There is no end mark for it.

<img src="an-image.jpg">
<img src="another.jpg" width="500" height="375">

Perhaps establish a tiled layout (split view) for previewing a set of documents with each at 50% width [need style attribute for non-pixel values], t.i. one pair at a time. Note that 50% + the width of one space character + 50% = more than 100%, so ensure there is no space between the end of one mark and beginning of the next.

src="doc-1.html" style="width:50%;height:30em;border-width:0">
src="doc-1_backup.html" style="width:50%;height:30em;border-width:0">
src="doc-2.html" style="width:50%;height:30em;border-width:0">
src="doc-3.html" style="width:50%;height:30em;border-width:0">

No matter what operating system, even from before the turn of the century, every computer comes with a simple text editor for editing plain text and an HTML viewer (a.k.a. web browser). Thereby, the document can be viewed in any web browser on any computer, and without need for a webserver or even an internet connection.

No special programs necessary, no extra cost, and HTML is as plain as the buttons on a buttonboard.

# essential HTML

The "language" in HyperText Markup Language (HTML) means it is a system or set of keywords. There is no communication by the means of HTML.

HTML marks are guidance for a temporary read-only view of a document. Sort of like proofreader marks, with a name consistently encapsulated within < and >. Sometimes after the name there is more describing the characteristics of the mark itself, before the >.

The angle brackets "< >" make the occasional HTML mark unmistakably distinguished from the prose, just like parentheses or square brackets. They are often readily available on the comma and period buttons of the buttonboard.

Any text can be placed in between < and >. Just type whatever. Programs providing a read-only view of a document with HTML marks generally ignore any unknown named marks and never show them.

The ".html" at the end of the filename for a document is typically the only (artificial) requirement made by the operating system and its applications. All HTML marks are optional, as such a document declared to be HTML can be just prose without any marks.

Links are "hyper" because the text is marked with an address for a location within the document or to another document. In other words, a link is an option to view some other part of the document or to view another document. A hyperlink is traditionally underlined by HTML viewers.

Mark a location in a document with an address mark and the id attribute. No need for anything within its region, merely type the marks before something interesting, like before a heading.

Mark text as hypertext with a reference href in an address mark <a href=""> before the text, then follow the text with the </a> ending mark.

In essence, making a note about another document typically involves typing the title of the document, and typing the address of where to find it. In other words, that is the act of referencing a source. A hypertext link is the same thing, with just a few more characters to type. The same information is recorded, and it will be a link in the read-only HTML view.

Include a framed view of either an HTML document or an image by referencing its address in an internal frame <iframe>. The view of the document or image is scrollable when larger than the internal frame, which also can have width and height attributes.

<iframe src="some-other-document.html"></iframe>

<iframe src="can-be-an-image.jpg" width="400" height="300"> This region is shown instead of the document only when a HTML viewer has no support for an iframe. </iframe>

Specifically add an image with the <img> mark and reference its source with the src attribute. There is no end mark for it. Optionally scale the image with its width or height attributes.

<img src="an-image.jpg">

<img src="another.jpg" width="500" height="375">

The same document or image can be referenced multiple times. That can be convenient for comparing side by side [perhaps each at 50% of the view width] one original version with many other versions, pairing a reference to the original version with each of the other versions.

Change the default characteristics of any mark with the style attribute for it. A colon associates a characteristic with its value, and a semicolon separates characteristics. Optionally use spaces around the colon or semicolon for clarity.

For example, set the width of a paragraph and center it horizontally.

text-align: right
;width: 50%
;padding-top: .25in
;border-bottom-style: double
;border-bottom-width: 2mm
;/* Using automatic margins
centers the region. */
margin-left: auto
;margin-right: auto
">For example, set the width of a paragraph and center it horizontally.

# dual-system personalizable computer, an approach

Be wary about putting all the eggs in the same basket. Discrete purposes with their own resources stay separate, thereby one is affected by its own needs or demise without draining other resources or damaging anything else.

In other words, rather than a large amount in one container, consider smaller amounts in multiple containers. Dedicating resources sparingly minimizes corruption or loss, while freeing remaining resources for additional or simultaneous endeavors.

An operating system needs its own memory storage, separate from other operating systems, because "operating" means automated programs are doing whatever without being monitored. They can readily corrupt anything on the remainder of the storage device.

For example, there has been one operating system that replaces the partitions and filesystems of the whole storage device with its new and improved version of partitions and filesystems. Unfortunately, the prior version of that same operating system is unable to recognize the storage device anymore, which means it is impossible to have it use the memory device, which impedes sharing that memory device with the newer version of itself. Reliability comes from discrete use, rather than shared.

Personalizable inherently means modular. The operating system is always kept on external storage, never permanently inside a personalizable computer. In that way, the computer can be started by attaching any operating system compatible with its hardware. Keep a backup on a second external storage device, then that can be use to start the computer instead.

Personal documents are always kept separate from the operating system, ideally on a separate storage device. In that way, they can be attached to any computer, rather than trapped inside a computer that fails to start. For example, personal documents on separate storage are easily taken to a computer located beyond a local electrical power outage, or simply attached to a nearby computer that uses a battery.

One computer with two memory storage devices for an operating (or operatable) system, primary and backup. Two more storage devices for personal documents, primary and backup. Perhaps another set of storage devices for additional software. The amount of memory per storage device can be minimized for each purpose, no need for terabtyes in one device. Operating systems tend to use only a few gigabytes, but some operating systems are only a few megabytes, f.e. TinyCore and piCore.

Never update nor upgrade an operating system, nor any software application. Instead, install the next version on a separate storage device, and try it out discretely without losing the currently working version. Creating a new instance fits with the core principle of computing: make and work on a copy.

Again, the memory devices need only as much memory as required for that particular purpose, no need for terabytes. Separate memory devices for trial of updates or upgrades can be reused for that specific purpose, discretely from personal documents and discretely from stable software.

Reliably customizing a computer requires using some other computer that is stable and remains stable. That is, a primary computer is used to setup a secondary computer. Once the secondary computer has its new modifications stabilized, then the secondary computer is eligible as a replacement for the primary computer.

Adding another computer requires only enough memory storage for its operating system (compatible with its hardware), but eventually two such memory devices: primary and backup. Once again, very small amounts of discrete memory rather than large amounts, t.i. gigabytes (or just megabytes) instead of terabytes, allows for sensible and affordable personalization of computers.

A physical computer tends to have small amounts of special memory for itself on its circuitboard, memory that can be updated by operating system updates or upgrades. That is why it is important to have a second computer for customizing, similar to the aforementioned possible corruption of other memory storage by operating systems.

By using a primary system to customize a secondary system, whatever happens to the secondary system (software or physical) can be assessed from the primary system. Furthermore, some tasks can be offloaded to the secondary computer (when it is stable enough) rather than stressing or slowing the priorities of the primary computer.

# pet rocks: wasteful manufacturing

[ This is eventually for a section of notes about the wastefulness of products, and the characteristics of a worthwhile product. ]

Some factors:

[ A collection of formerly useful products is comparable to a collection of interesting looking rocks, also known as pet rocks. Such a collection of novel contraptions might be worthy for a museum, but is more of a reflection of prior personal interests (perhaps no longer accurately representing). ]

# Resources

# Markup a CSS stylesheet

A stylesheet for stylesheet documentation, a.k.a. a hybrid CSS+HTML document.

The "style" of Cascading Style Sheet refers to expression rather than decoration, because CSS is for changing the default spacing and drawing of HTML marked regions of plain text documents. Therefore, CSS actually describes the characteristics of HTML marks rather than the document.

The intent of a CSS stylesheet is documented with comments embraced by /* and */. Comments can be marked up with HTML, whereby documentation for a stylesheet can have an alternate view in an HTML viewer.

A well-documented stylesheet inevitably links to itself for providing samples of its rules within its documentation. Therefore, a "stylesheet stylesheet" such as this one is "the mother of all stylesheets", as it precedes and begets all thereafter.

# PDF: portable document format

Portable Document Format (PDF) describes how to layout text and images, and is plain text. Basic notes for PDF version 1.4, mostly with the purpose of combining images into a single PDF document.

# ed and emacs, an approach

For many decades, emacs (Editing MACroS) has provided split-view management of documents (viewing and editing). It also excels with memory management of any sequence of typing or list of commands by storage in "registers", or complete repetition by a single press of any button desired (a.k.a. keyboard macros). The Emacs command "append-to-buffer" provides a means for selectively transferring content from any view of Emacs (whether a document or otherwise) to any other view, bypassing its own copy/paste or "registers".

On the other hand, the text editor "ed" reveals any fragments of any number of documents when requested, in any order, gradually filling the screen only as needed. Each line is called forth by its number, so the line number is an intuitive command that shows that line of text. With "ed", there is no need for moving a text cursor, no need for selecting text, and no need for scrolling.

Any comma-separated range of lines is a command for calling forth that range of lines, f.e. 31,35p will "print" lines 31 to 35 on the screen. Line numbers are optionally revealed when requesting lines (f.e. 31,35n), and similarly so in search results. Specify a generic line number with plus or minus, f.e. -4 for the fourth line before the current line, or for a range of lines, f.e. -5,+5p to "print" the range of lines of text before and after the current line. The last line requested automatically becomes the current line.

Thereby with "ed", views of text emerge naturally from requested fragments of familiar documents: command, lines of text, command, lines of text, etc. That is, the typed command remains visible and serves as an introduction for the lines listed by it (when any).

A document can be viewed one screenful at a time (with z), or by an arbitrary number of lines (f.e. z30 for the next 30 lines), from anywhere within a document (f.e. 42z30n for the 30 lines starting from line 42, and numbered).

Search results are listable, or traversable one at time by line number in any order desired, and repeatable without retyping the search pattern. In addition to mere search and replace, a set of commands can be applied to all search results or interactively queried for each one. For example, search for a pattern, but also specifiy a different pattern for replacing in the results, all as one command, and either immediately or selectively.

As aforementioned, the editing commands typed in "ed" remain visible, thereby keeping a history of how a document was edited (optionally with the lines of text before and after they were modified) would be possible... if only there was a means for saving those proceedings.

By using "ed" for its naturally emerging document views within the "shell-mode" of Emacs, the "ed" program gains a separate dedicated buffer from Emacs recording that history of all editing with "ed", along with robust command editing (from the text editing commands of Emacs) when typing its own commands. Of course, the aforementioned keyboard macros from Emacs means commands within "ed" are automatically added to any recorded sequence of tasks, and naturally so. No special effort needed, nothing new to learn, automatically incorporated.

Evoking "ed" within shell-mode with sudo (super-user do) means the ability to edit restricted system documents without having to do "sudo emacs", thereby the super-user role remains optional within Emacs.

With the "!" command provided by "ed", evocation of external commands are possible from within "ed", and their results optionally inserted into that document wherever desired. Evoking "ed" as super-user (t.i. "sudo ed") also means there is no longer any need to type sudo for each and every command that requires super-user privileges, because the "!" command of "ed" will evoke external commands with the same privileges by which "ed" itself was evoked.

The split-view management of Emacs provides the opportunity for multiple full-screen layouts of several such instances of "ed" and "sudo ed" in shell-mode, intermixed with any other activities within Emacs, f.e. email, web browsing, directory listings, etc. As each instance has its own dedicated buffer, the editing history of commands used in "ed" or "sudo ed" can be saved for review or potential selective restoration of edited documents (for when lines were listed before and after editing them). And of course, repetition of super-user tasks, editing or otherwise, becomes possible (and naturally so) by means of the aforementioned keyboard macros of Emacs.

Using "sudo ed" within shell-mode of Emacs enables responsible, recordable (t.i. record keeping), and administrative editing of documents or evocation of commands with access to copious amounts of copy/paste access (a.k.a. "registers"), and ridiculously easy on-the-fly record/play of any sequence of typing and commands... readily assigned to any button desired, as many as needed.

# lisp and NIL: No Items in List

Embracing items with parentheses
 acknowledges those items
 are associated with each other.

Nil is an empty list,
 as in "nothing in list".
 But that also asserts "Nil Is a List"
 rather than nothingness itself.
 It has become the mnemonic name
 for an empty set of parentheses.

   nil  ==  ()
        ==  '() ; quoted form

A list of one item
 is never notated as a list,
 t.i. it has no parentheses.
 It is written simply as the item itself,
 for there are no other items associated.

A list of more than one item
 is notated as a dotted list,
 with a spaced separated period
 before its final item.

   '(one two . three)

A list with nil as its final item
 is commonly abbreviated
 without dotting with nil.

   '(one . nil)  ==  '(one)

A list of items without
 a dotted final item
 has visually consistent
 delimitation, thereby
 is a "proper list".
But as a list without
 a dotted final item,
 a proper list is merely
 the abbreviated form
 for its items dotted with nil
 as the final item.

   '(one)  ==  '(one . nil)

As such, a proper list with only nil
 is a list with an empty list:

   '(nil)  ==  '(())

 but is also the abbreviated form
 for a list of items dotted with nil
 as its final item:

   '(nil)  ==  '(nil . nil)

 which is a dotted list of two lists,
 or the egregious enlightenment emoticon
 for "I am become nil":

   '(nil)  ==  '(() . ())


Consing constructs a dotted list.

   (cons 'one 'two)
     ->  '(one . two)

Multiple consing results in
 the last item added
 becoming the first.

   (cons 'three       ; second cons
    (cons 'one 'two)) ; first cons
      ->  '(three one . two)

Consing an item with nil
 results in a proper list,
 because a proper list
 is the abbreviated form
 for its items dotted with nil
 as its final item.

   (cons 'three            ; third cons
    (cons 'two             ; second cons
     (cons 'one nil)))     ; first cons
       ->  '(three two one . nil)
       ==  '(three two one . ())
       ==  '(three two one)

A proper list beginning with nil
 begins and ends with a list.

   (cons nil '(one))
     ->  '(nil one)
     ==  '(nil one . nil)
     ==  '(()  one .  ())

# StumpWM: an instantaneously extensible computer interface

The split-view manager StumpWM is a lisp image exported from SBCL (Steel Bank Common Lisp), and is intended for managing the Xwindows of an Xserver.

Split-views are adjacent non-intersecting areas, like tiles, thereby efficiently encompassing the whole screen. Initially, StumpWM was known as "ratpoison" because it focused on eliminating any requirement for an electronic device emulating the toggling of the buttocks on a rodent.

As an SBCL Lisp image, StumpWM is actually a copy of the SBCL lisp interpreter with the code for StumpWM built-in. That means starting StumpWM is the same as starting a lisp interpreter, and any new lisp can be typed and evaluated instantly. While it is typical to modify a lisp interpreter while using it, in this case that means being able to modify StumpWM while using StumpWM, too. No need to start over, just keep going.

Additionally, StumpWM is written entirely in Common Lisp, and SBCL is written mostly with Common Lisp. Technically, that means either the Xwindow manager or the Lisp environment can be personalized with the familiarity of Common Lisp, at first without recompiling and then compiled later for a copy with permanent additions. (But... SBCL has a lot of code, so modifying StumpWM is more approachable.)

Personalize StumpWM with its initialization file "~/.stumpwm.d/init.lisp", such as adding keybindings or new actions. Or, include lisp from other files when starting by adding lines like:

(load "~/common-lisp/something-new.lisp")

After starting the Xserver with StumpWM as the Xwindows manager, access the Lisp interpreter anytime with "Control-t :". That is, hold the Control button then type the letter t, then let go of the Control button, then type a colon. The prompt "Eval: " will appear for typing a line of Common Lisp.

Instantly add a new keybinding for a command, or create a new Xserver window and draw in it, or add a set of new commands from any file with load. In a nutshell: an instantaneously extensible computer interface.

# Example setup of StumpWM.

StumpWM: StumpWM manual. StumpWM wiki (tips and tricks).

Steel Bank Common Lisp (SBCL) 2.1.0

alexandria 1.0.1

cl-ppcre 2.1.1

Common Lisp X Interface (CLX) 0.7.5

  • CLX manual
    Likely the same as its info document viewable with Emacs.

an Xserver, f.e.

Tiny Core,

For example, piCore 12.0 (includes 64-bit version).

# Reading and writing with the Lisp interpreter.

Like a notepad of paper, one of the basic experiences with a computer is memory management. A label or short phrase such as a heading becomes a concise summary for a paragraph or section, a reminder of the content for quickly skimming or referencing by name later. Similarly, an index listing cross references a label or short phrase with a location such as a page number.

[ In fact, it is generally a good idea to have a notepad of paper next to a computer for making notes on how to operate the computer. Computers rarely come with manuals nowadays. ]

The means for associating a nickname with information on a computer has generally been obscure with the software pre-installed on it. However, a Lisp interpreter such as SBCL used by StumpWM makes it straightforward with the Common Lisp setq function (CLHS). Any information can be noted in the Lisp interpreter by associating a label with it.

remember "Something to remember."
a-label  "And one more thing.")

The evaluation prompt provided by "Control-t :" in StumpWM waits for only a single line, suitable for a quick short note. Use the Control button just like the Shift button, t.i. hold Control and type t, let go of Control, then type a colon. The prompt "Eval: " appears on the screen ready for a parenthetical form of Lisp, which will evaluate it after the Return or Enter button is typed.

Eval: (setq a-symbol "A label is a Lisp symbol.")

A message with the results, when any, temporarily replaces it on the screen for a few seconds and then disappears.

"A label is a Lisp symbol."

To see it again, simply type the name in the evaluation prompt again, and type the Return or Enter button. The name will be evaluated, and once again a message with the result will be displayed for a few seconds, then disappear again.

Eval: a-symbol
"A label is a Lisp symbol."

Lisp is meant for LISt Processing, hence its name. A list can be constructed with the cons function (CLHS), even by consing with an empty list. Of course, a label can be re-used, too.

Eval: remember
"Something to remember."
Eval: (setq remember (cons remember ()))
Eval: (setq remember (cons "Curiosity wins the peace prize." remember))
Eval: remember
("Curiosity wins the peace prize."
 "Something to remember.")

Add values from other symbols to the same list in the same way.

Eval: (setq remember (cons a-label remember))
Eval: remember
("And one more thing."
 "Curiosity wins the peace prize."
 "Something to remember.")

Perhaps more convenient is the push macro (CLHS) for adding an item to the beginning of a list.

Eval: (push a-symbol remember)
Eval: (push "A quick note." remember)
Eval: remember
("A quick note."
 "A label is a Lisp symbol."
 "And one more thing."
 "Curiosity wins the peace prize."
 "Something to remember.")

The information is accessible only while the Lisp interpreter exists, so it will be gone after quitting StumpWM or turning off the computer.

# Reading and writing with the computer medium.

Writing information to a document in computer memory so it will be available the next time the computer is turned on is done with the Common Lisp with-open-file macro (CLHS) and the format function (CLHS).

Unfortunately, both with-open-file and format have a million options, the former because it uses the open function (CLHS), and the latter because it uses tilde expansions (CLHS 22.3).

So, focus on what is desired: write to a document; it might be non-existent; append to the document when it does exist. Nonetheless, it turns out this still makes the eyes water, because it is a bit much to be typing into the Lisp interpreter every single time.

(a-name-for-this "/actual/name/for/document"
:direction :output
:if-does-not-exist :create
:if-exists :append)
(format a-name-for-this
"What you can do, while weeping."))

Furthermore, information referenced by a label or name (as aforementioned) might be text for personal reference, or it might be Lisp for later evaluation by the Lisp interpreter. For example, the Lisp interpreter will want double quotes around text, so ~s for "Lisp symbols" (CLHS will ensure that happens from the format function. Any other text can still be included, even a blank line.

(setq another-symbol "One more thing.")
(a-temp-name "/actual/name/for/doc-with-lisp"
:direction :output
:if-does-not-exist :create
:if-exists :append)
(format a-temp-name

By using ~s, the document will have at the end of it the text within double quotes.

"One more thing."

That makes the content suitable for giving it to the Lisp interpreter with the read function (CLHS). Using with-open-file is simpler when reading a document, just use :direction as :input. Use setq to label the results from read.

(setq got-this-from-a-document
(a-temp-name "/actual/name/for/doc-with-lisp"
:direction :input)
(read a-temp-name)))

For text that will never be used with the Lisp interpreter after writing it to the document, use ~a for "as is" (CLHS

"And the other thing before this.")
(a-temp-name "/actual/name/for/document"
:direction :output
:if-does-not-exist :create
:if-exists :append)
(format a-temp-name

Using the ~a with format results in the text from the named symbol without additional double quotes.

What you can do, while weeping.
And the other thing before this.

As such, it would be more convenient and less teary-eyed to have a specific command for writing text to a document, and a separate specific command for writing Lisp to a document.

(Ftext Fdoc)
( ;;; Prompt for text.
"Type the text for the document
: ")
;;; Prompt for document name.
"Document name for writing that text
: "))
;; Description shown with "Control-t f".
"Append text to the document.

Begins on a newline in the document
 before appending the text."
(WOFdoc Fdoc
:direction :output
:if-does-not-exist :create
:if-exists :append)
(format WOFdoc

The prompts make it convenient to use "Control-t ;" (a semicolon) for typing just the command name: text-to-doc. However, a command is also a function and so it can also be used with "Control-t :" for evaluating a parenthetical form.

(text-to-doc "Some info." "/tmp/a-doc-name")

Evaluation also makes referencing labeled information possible.

(setq last-thing "This is it.")
(text-to-doc last-thing "/tmp/a-doc-name")

As for a separate command for writing Lisp to a document, consider duplicating this command and renaming it lisp-to-doc, or whatever desired. Then change the ~a to ~s, and modify the prompts and documentation suitably. A similar command is used for collecting and restoring marked points, along with one for reading lisp from a document.

The lisp-to-doc command would work the same except, as aforementioned, double quotes will encapsulate each new text added to the document. While ~a sometimes provides the same results for parenthetical Lisp forms, there are other aspects of Lisp notation that are ensured by ~s to be readable by the Lisp interpreter.

As would be expected, actual Lisp notation can be written to the document by prepending a single quote mark to the Lisp notation when evaluating the command with "Control-t :".

(lisp-to-doc '(one two three) "/tmp/a-lisp-doc")

The parenthetical Lisp form is written on a new line at the end of the document. Note there are no double quotes because it was a parenthetical Lisp form rather than double quoted text.


Of course, referencing labeled information works the same as before.

(setq a-lisp-thing '(four five))
(lisp-to-doc a-lisp-thing "/tmp/a-lisp-doc")

And doubly of course, a label is a Lisp symbol, so using a single quote before a label will get the label itself written to the document rather that what it references.

(lisp-to-doc 'a-lisp-thing "/tmp/a-lisp-doc")

Notice that the label will be written with uppercase letters.


The reason labels in Lisp become all uppercase characters despite written in lowercase is likely because Lisp might have emerged before lowercase characters were used with computers. That is reasonable because computers are an extension of the telegraph system which also used only uppercase letters, as Morse Code had no lowercase letters.

That is also why a computer transfers information as dots and dashes between its own electronic components, and across the Internet. A computer also writes documents with dots and dashes to its memory. Nowadays, it is a modified version of American Standard Code instead of Morse Code from the telegraphing days. Despite the journalistic rumours, there are no zeros and ones in a computer and no binary numbers, there are only electrical pulses of dots and dashes.

# X Window System and its protocol, a translation of a misnamed paradigm.

A "window" is a misnomer for a designated area, typically rectangular. An area is simply the coordinates for its left-top corner associated with its width and height (rather than its kittycorner coordinates): (x, y) (w, h).

Various shapes within an area are displayed by declaring two different colors (background and foreground), the type of shape, and the method of merging the intersection with other prior drawn shapes within the same area. That is, each area constrains its own content, but shapes merge by a variety of methods (sixteen) within the area, f.e. merging of a red shape and a blue shape can make their intersection purple.

Abutting each designated area along their edges presents a split-view of the areas, like tiles. The X Window System protocol limitedly supports intersection of the designated areas themselves by means of a single priority list for the areas. Intersecting areas of higher priority are subtracted from areas of lesser priority, like what remains as each area is cut from a piece of paper.

Therefore, the designated area that has the highest priority maintains its rectangular shape because it has no intersecting areas subtracted from it. The other areas maintain their shape when intersecting only lesser priority shapes, if any intersection at all. This also implies there is no true transparency effect for an area, because designated areas are only subtracted and never merged.

In other words, the designated areas are meant to be rectangular and their intersections are subtracted, whereas a variety of additionally described shapes can merge with each other within a single designated area.

Furthermore, a designated area can have areas designated within its bounds prioritized amongst themselves, but those internal areas are forbidden from extending beyond the outer area. Obviously, those subregions are intersecting with whatever shapes have been described within the overall area, but only by means of subtraction because they are designated areas instead of shapes.

A pixmap, t.i. a picture map, is a simple list of dots (pixels) associated with a color for each dot. The content of a designated area can be exported as a pixmap. A pixmap can be applied fully or partially anywhere within any area, and can be assigned as the background of any area. The Xserver automatically applies the background of a designated area for the pixels that area has priority, but any other described content is managed separately by external software (t.i. a client) when it receives notifications from the Xserver.

An intersection is visibly changed by the higher priority area for that intersection. As such, a designated area with no content and no background seemingly acquires all pixels within its boundaries from either the overall backdrop of the Xserver or from lesser priority areas, with no further visible changes from modifications of intersections with lesser priority areas.

# Modifications for StumpWM.

The most immediate change to StumpWM is applied with the "eval" command, available with Control-t then colon, usually notated as "C-t :". That is, hold the Control button then type t, then let go of the Control button, then type a colon. Note that using the Control button is just like using the Shift button, no special technique. The prompt "Eval: " appears and awaits the entry of any short Common Lisp statement, about the width of the screen.

However, that can also be the means for loading a file with a more comprehensive change written with Common Lisp, by using the load function. For example:

(load "~/.stumpwm.d/custom/points-later.lisp.html")

The ".lisp" suffix is common for files with Lisp, but is optional because Lisp is just plain text, just like HTML and CSS.

# Changing the "C-t" prefix for default keybindings.

It is possible to type a command instantly without any place to type it. Silly, but that is how computers have been since forever it seems. The key to doing that is typing a special button or sequence of buttons, buttons that usually produce no symbols on the screen. These are usually short sequences, abbreviations of the actual command names themselves.

For StumpWM, the default special sequences of buttons begin (t.i. is prefixed) with the short sequence of Control and t, usually notated as "C-t". The Control button works just like the Shift button, it must be held down before typing other buttons in order for it to have an affect. Therefore, hold the Control button, then type t, then let go of the Control button, then type the rest of the sequence for the desired command.

For example, the special sequence "C-t ?" is for obtaining a listing of default StumpWM commands and their abbreviated special sequences. The listing itself actually shows only the remainder of the required sequence for a command, without the prefix "C-t". That is, the command for showing the time is evoked with the special sequence "C-t a", but the listing shows only the "a" for the time command.

The help listing also has entries like "g   *GROUPS-MAP*" and "h   *HELP-MAP*". That means, for example, the sequence "C-t h" is yet another prefix. Conveniently, adding a "?" after any prefix will list the commands mapped to that prefix, just like it did with "C-t". So, "C-t h ?" reveals all the commands that begin with "C-t h".

Change the default prefix for StumpWM commands with the function stumpwm:set-prefix-key (2.2 Binding Keys), such as within the initialization file, "~/.stumpwm.d/init.lisp". For example, to make the F5 button on the buttonboard the new prefix:

(stumpwm:set-prefix-key (stumpwm:kbd "F5"))

From then on, "C-t" will no longer work as the prefix, but instead the F5 button will need to be used as the prefix. For example, use "F5 ?" for the listing of commands instead of "C-t ?". Maybe cut a small piece of paper with "stumpwm" written on it, and tape it next to or on the button for the prefix.

Of course, that can also be evoked with the lisp evaluation prompt without having to restart StumpWM. Just use "C-t :", or, uhm, with whatever the prefix happens to be at the moment, and then type the line at the "Eval: " prompt that appears.

# Remapping the caps lock button.

The caps lock button is probably more convenient than the F buttons. Using it seems to require remapping the buttonboard with a command beyond StumpWM, the "xmodmap" command, after discovering the keycode for the caps lock button with the "xev" program. One way is to remap the caps lock button to an F button, something from F1 to F35, perhaps preferably a non-existing F button so the other F buttons can still be used for something else.

The keycode for buttons when pressing them can be observed with the program "xev", for example (with the command line, but not the lisp interpreter):

xev \
-geometry 200x200+500+350 \
-event keyboard

Presuming that revealed the keycode for the caps lock button as 66, the "xmodmap" program can be used to remove the caps lock functionality from the caps lock button, and then map it an F button. The StumpWM manual (2.3 Modifiers) has some info about this, too.

xmodmap \
-e 'clear lock' \
-e 'keycode 66 = F20'

The command line has often been referred to as a "shell" for many decades now, so there is a lisp function in StumpWM named stumpwm:run-shell-command (11. Interacting with UNIX). As such, that can be used for programs like "xev" and "xmodmap".

; Remap the caps lock button to F20.
"xmodmap -e 'clear lock' -e 'keycode 66 = F20'")

Of course, that means that can be done with the lisp interpreter from "C-t :", or added to the initialization file "~/.stumpwm.d/init.lisp" for remapping the caps lock at startup of StumpWM, too. Obviously, once the caps lock button is remapped to an F button, then the caps lock button can be the prefix for StumpWM default commands by means of the aforementioned function stumpwm:set-prefix-key.

; Caps lock button was remapped to F20.
(stumpwm:set-prefix-key (stumpwm:kbd "F20"))

# Alternative for pointer activation.

The basic pointer activation in StumpWM (the Xwindow manager formerly known as "ratpoison") depends on a legacy function named "ratclick", which might fail when the source and version of the CLX library is without support for the XTEST extension for the Xserver. Even when it is supported, the function name might be different than what is requested by StumpWM:

For example, the actual function needed has been in the CLX "test/" directory, and from there will be known instead as:

Perhaps edit a new text file (in whatever text editor) and make a new StumpWM command (3.1 Writings Commands) using that xlib function for the desired button: 1 for the primary button, and 3 for the secondary button. Documentation can be nice, too, when querying help for the function with "C-t h f". After loading the file, the command will be available, or errors (red message text) will be reported (so edit and load again).

(stumpwm:defcommand activate-pointer
((:number "Pointer button number (1-5): "))
"Press and release a specific pointer button.

Use 1 as the button-number for the primary button,
and 3 as the secondary button (a.k.a. right-click)."
The xlib/test function also requires
 the current display.  That is provided
 by StumpWM as *display*.
;; First, press the button.  Requires t.
stumpwm:*display* Fbutton-number t)
;; Then release the button.  Requires nil.
stumpwm:*display* Fbutton-number nil))

Perhaps bind the command to a button on the buttonboard, perhaps one each for button 1 and button 3. For example, the 1 and 3 on the numeric keypad might be "KP_End" and "KP_Page_Down".

; Bindings for activating the pointer buttons.
(stumpwm:define-key stumpwm:*top-map*
(stumpwm:kbd "KP_End") "activate-pointer 1")
(stumpwm:define-key stumpwm:*top-map*
(stumpwm:kbd "KP_Page_Down") "activate-pointer 3")

One way to find the names of buttonboard buttons is with "describe-key" in StumpWM, available by default as Control-t h k. It prompts with "Describe Key: " and waits for a button to be pressed. Then it reveals the names of the pressed button or sequence of buttons, and the command assigned to it, when any.

Consider activating buttons for a motionbox without jostling it, for when the Xserver cursor is already in the perfect location.

# Alternative for drag'n drop.

A dragon would probably drop what a bird typically drops, as they both have a cloaca, but likely a bit more biohazardous for anyone underneath it. Similarly, accidentally letting go of the button on a motionbox while trying to reposition the cursor might be disasterous, or at least lead to extra work to undo the accident.

The Xserver keeps track of whether a "pointer button" has been pressed, as well as any pressed modifer buttons on the buttonboard intended for that pointer button. As such, it is possible to toggle a button press and a button release individually with the same command bound to a single button on the buttonboard instead.

The Common Lisp X Interface function xlib:query-pointer (CLX 13.5 Pointer Position) reveals what pointer buttons are pressed, by means of the fifth element it returns.

(multiple-value-call 'list

For example, when button 1 is pressed, the result from it is 256, because it is actually the binary mask: 00000001 00000000. The first part (from right to left, just like decimal numbers) indicates the modifer buttons pressed on the buttonboard, with zero meaning nothing pressed. While 2^8 is 256 (t.i. 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2), the eight bits include zero, therefore the first byte is 0–255. A ninth bit is required to begin the next range for 256–511 (instead of 512 for 2^9), which is why the ninth bit is 1 and represents 256.

A decimal number can be used as a mask, which is why the results of xlib:query-pointer returns "256". The binary "1 00000000" is merely a different way of writing the number, rather than a different number. Specifically, in Common Lisp #b100000000 means that is a binary number, which is 1 with eight zeros, the aforementioned "256".

The Xserver seems to track only five pointer buttons, so only the first five bits are used of the second 8-bit byte. That means when there are five buttons on a motionbox and all are pressed (and held), and with no modifier buttons pressed, then the Xserver would return the number known in binary as: 00011111 00000000.

One way to programmatically determine from the bits of such a number which button is pressed is with Common Lisp logic functions (CLHS 12.2 The Numbers Dictionary). For example, logand can compare each bit from two numbers and return a new number. Only the bits for the positions that are 1 in both numbers will be 1 in the new number, otherwise a bit will be zero. Order of the numbers for logand is of no matter because it is only a comparison.

   00011111  -  all five buttons are pressed
   00000100  -  mask representing button 3
   00000100  -  this figured out button 3 is pressed

   00000001  -  only button 1 is pressed
   00000100  -  mask representing button 3
   00000000  -  this figured out button 3 is not pressed

A number can be manipulated like a mask by using "arithmetic shift" to shift the bits to the left or right, by means of the function ash. That means "00000001" (binary for 2) shifted by 3 becomes "00001000" (binary for 8), because a positive shift is leftwards. In other words: 1 * 2^3.

 (ash 1 3)
   => 8

Since buttons 1–5 are positions 1–5 in the 8-bit byte, then the mask for a button can be made by shifting a "1" until it is in the same position. For exmaple, "00000001" to "00000100" for button 3 would be a shift of 2, which is one less than the button number.

 (setq button 3)
 (ash 1 (- button 1))
   => 4

Therefore, a command can be written to inform the Xserver a pointer button has been pressed, and the same command can be used for releasing the pointer button by confirming the button with the mask the Xserver returns when the pointer is queried.

Toggle primary button for "press" or "release", f.e. text selection, drag'n drop without accidental drop, or anything else distinguishing a button press from a button release event.

# Alternative for pointer placement.

The Common Lisp X Interface function xlib:warp-pointer (CLX 13.5 Pointer Position) when given an Xwindow and coordinates will place the pointer at those coordinates within the area of that Xwindow.

Coordinates of the current position of the pointer can be retrieved with a couple of functions. The function xlib:pointer-position (CLX 13.5) when given a specified Xwindow returns the coordinates of the pointer (and some more data). Alternatively, the function xlib:global-pointer-position (CLX 13.5) when given a display (like stumpwm:*display*) returns the coordinates of the pointer and the root window.

These functions make use of the Common Lisp peculiarity (contrary to other Lisps) of "returning multiple values", t.i. returning a series instead of a list. Only the "primary value" gets noticed unless the Common Lisp special operator multiple-value-call (CLHS 5.3 The data and control flow dictionary) or a similar "multiple-value-" macro is used for accessing all the "returned" values, f.e. as an actual list.

(multiple-value-call 'list

# Mathemagical Xserver cursor placement.

Much like split-view management, the Xserver cursor can be placed anywhere within the bounds of a screen by halving it. Begin in the center of a screen, then split it (left, right, top, or bottom) and center the cursor within one of the halves.

Xserver cursor placement by mathemagically halving the screen, rather than arbitrary pointer motion. That is, no more need to use the force of dramatic physical gestures to move anything. Basic center, left, right, up, and down for positioning quickly, or go back to previous point or the screen center.

Includes pointer activation, and keybindings (for numeric pad), and inspiration...and a "Content outline" for the copious documentation. It is all quite simple, really; the fluff is in the doc rather than the code.

Or, recenter the Xserver cursor at any halving point and it becomes the beginning point. Going back stops at that halving point. Returning to the beginning returns to that recenter point, then returning once more makes the screen center as the beginning point once again.

# Mathemagical pointer and cursor placement.

A single destination:

          y axis
 x axis --+--------------------------------
          | origin       up
          |              |
          |              |    # destination
          |              |
          | left --------+-------- right
          |        point |
          |              |
          |              |
          |             down

Extending lines from the point isolates the destination within a quadrant and reveals the pointer trajectories for intersecting with the destination. Limiting the length of the lines to the width and height of the narrowed region reveals the current precision and the progress.

Many potential destinations:

          y axis
 x axis --+---------------------------------------
          | origin           up
          |                  |
          |                  |
          |                  | destinations
          | left ------------+--#--#--#--#-- right
          |            point |
          |                  |
          |                  |
          |                 down

Multiple potential destinations might be axially aligned, f.e. a menu of options or a toolbar of outlined regions. Placing the pointer first along their axial alignment frees the other axis for selecting any of the items. Another option can be chosen by backtracking a little rather than starting over at the center of the screen.

The pointer has four parts that imply the crossing of a horizontal line with a vertical line. A gap for the implied intersection also provides the visual clearance needed for the Xserver cursor when activating the pointer buttons.

Other programs continue controlling the appearance of the Xserver cursor within their views without interference from the halving pointer.

Pointer placement by mathemagically halving the screen, rather than arbitrary pointer motion includes buttonboard bindings (for numeric pad) for multidirectional placement, and complementary commands for activation of the motionbox pointer.

Consider recentering the pointer and Xserver cursor at any halving point and it becomes the beginning point. Going back stops at that halving point. Returning to the beginning returns to that recenter point, then returning once more makes the screen center as the beginning point once again.

Either way, the pointer-halving-show command conveniently returns the cursor that has been moved (f.e. by a motionbox) back to the pointer position, and pointer-halving-hide hides the pointer without hiding the Xserver cursor. Or, consider combining the commands into pointer-halving-reveal-toggle for toggling revealing and hiding of the pointer.

# Make a point, collect them all, restore them later.

Convert a pointer interface into a selection interface. First, move the Xserver cursor by whatever means available, then mark the location for returning the cursor to it later. Each point is then available as next or prior. Eliminate traversal of a vast void, and never miss a point.

With the convenience commands points-write and points-read, write a list of marked points to a document, then later read and apply that list of points to restore them for use again. Perhaps collect a group of preferred points for a specific program, then swap them for a group of points from another document for another program.

Convert "drag and drop" into "select and put" by adding pointer button activation commands for toggling the press or release of the primary pointer button from the buttonboard.

The hot spot for the Xserver cursor must have clearance when activating a pointer button. A point is drawn as a white perimeter of a square with a black mask, made from four Xwindows.

    ______        _   __   _
   |  __  |      | | |__| | |
   | |  | |  ==  | |      | |
   | |__| |      | |  __  | |
   |______|      |_| |__| |_|

The left and right sides each have a black background, and a subwindow with a black background and a white border as thick as the line for the square perimeter.

For example, the left side (though taller than this):

    window              -->   cropped
    ______                    ______
   |  ____|__                |  ____|<-mask
   | |       |               | |    |
   |b| w _   |               |b| w _|<-perimeter
   |l| h| |  |               |l| h| |
   |a| i| |  |               |a| i| |<-black mask
   |c| t|_|  |               |c| t|_|
   |k| e     |               |k| e  |
   | |_______|subwindow      | |____|
   |______|                  |______|

The top and bottom sides each have a black background, and a subwindow with a white background as wide as the sides and as tall as the perimeter height.

    top or bottom
   |____________|<-black mask
   |subwindow   |<-white perimeter
   |____________|<-black mask

# generational and archæological loss of the computer medium

Writing and reading is the basis of the computer medium. Freedom of expression, t.i. the result of a person taking on the responsibility of speaking for itself, is what has been curiously missing with the commodity computers sold to the everyday person. Choice is often the only opportunity given to the purchaser of a computer, choosing amongst decisions already made by the software developers.

The skill of writing and reading has been impressed upon as many people as possible, and has become an expected means of learning and communicating. However, the computer medium is sold as a means of looking and pointing at options thought of by somebody else, failing at integrating with the flow of thoughts and actions of the everyday person implementing the computer medium. Paying money for a computer and then having applications do what somebody else wanted to do can only be a novelty, merely entertaining a person whose desires were never asked.

A computer application, a type of software, is an example of grouping basic commands for a specific task. Obviously, that is very useful for the person who groups them, and less so for a person when they are grouped by someone else.

Sometimes a single command is a group of other commands rather than emerging from new computer programming. A list of commands can be saved for later recall as a single command, f.e. by repeating the sequence of commands the person has just done.

Arbitrary actions with a pointer are prone to misinterpretation when part of automating repetitious activities. A shared command whose composition can never be explored, whose list of subcommands is forbidden from discovery, is an insincere gift that will fail to support the everyday person to correct it, simplify it, or adapt it for personal comfort.

Ultimately, personal expression is supported by writing and reading, impeded by insincere sharing, and essentially neutralized by having only choices. Sharing an approach inspires and supports the emergence of new approaches, with dissimilarity possible though unrequired.

The computer medium is inferior (f.e. when compared with pen and paper) for promoting self-education and cultural growth when it is distributed as an unexplorable trade secret providing a kiosk of choices rather than unrestrictedly adaptable by the everyday person for each moment of life.

# recipes and pseudocode

An approach is a recipe or pseudocode, and its application is the result.

A recipe declares an intent by means of a list of ingredients and events that have been effective for producing a desired result. An application is the result of the recipe, a final presentation either palatable or inedible.

A computer application is typically somebody else's execution of an approach, somebody else's results. With a computer, an application of an approach is invariable, but pseudocode is by definition a recipe and therefore an adaptable approach. The pseudocode is the gist and intentions, the springboard for a variety of forms, thereby distinct from any specific attempt.

Life is variable. Therefore, the predefined results of applications are inapplicable to the ever changing flow of events. On the other hand, an approach is guidance for transitioning through a moment, retaining opportunity for adaptation with each jump.

# not documentation

Too often computer programs have been said to be lacking documentation. In fact, it is the other way around. Expression of intent has been without follow through. Without intent and motivation, there is no pursuit.

Without well thought out desires recorded, results like a set of computer program instructions are without a foundation.

A computer programming language is merely a set of symbols or codewords. A computer is simply a machine, a piece of hardware, there is no possible communication with it. Instead, such a "language" is for a person briefly recording a set of instructions. Unfortunately, a computer program without documentation is as informative as a quote taken out of context.

Ingredients are fabricated with the computer programming language, or perhaps parts of the computer hardware are activated with it. Even then, the phrases and terms need to be interpreted as a specified sequence of toggle switches within the circuitry of that machine, typically a barebones coding with only two letters in its alphabet and no phonemes because it is never spoken.

In other words, the computer is just a tool chosen for applying an appoach, and a computer language records mere gesticulations of the person applying the approach. Therefore, the approach or purpose is inherently underivable from the computer coding, as it is no more than the pattern on a wall of toggled switches.

An approach must be recorded before or as it is applied if it is ever to be known by anyone else, as many archeologists have lamented. Minimizing it by shedding its context of intent and motivation deprives everyone of its meaning, even the later self of the person applying it.

To reiterate, there is no communication possible with a computer language, for it is intended only for toggling switches for a result rather than sharing an understanding. A computer program is merely one adaptation of an approach, one choreographed dance for a feeling, forever unrevealing of its own inception.

# an operatable system

A computer is a medium for writing and reading, with the writing reduced to mere presses of labeled buttons for each letter of an alphabet. There is no other skill needed for operating a computer, though there are sometimes other means besides a buttonboard.

A computer is operatable, and automatable, when it is capable of restoring what has been recorded within its medium. That is, a computer recording the actions done with it in the moment and then repeating those actions upon request is being operated.

A system of programs operating on their own, especially when unmodifiable, is an "operating system". Somebody else's program is somebody else's operation of a computer, recorded from some other moment for that other person.

As a computer program is a proxy for the person who created it, vetting a computer program is the same as trusting the person who wrote it, perhaps a complete stranger. A computer virus is merely a computer program. A system readily operating on its own, t.i. an operating system, is operating for the interests and intentions of the people who wrote the programs.

In contrast, an "operatable system" does nothing until it is operated, so known programs can be the only programs ever activated or automated, per the decisions made by the person operating the computer.

There is no denying the various computer mediums are archeologically unsound. That makes it all the more important for using the computer medium as freely as possible during this transition beyond the computer medium itself for more sustainable, sharable, and perusable recording mediums. The medium of pen and paper (as an example of the latter) preceded the computer medium, and is destined to continue beyond the computer medium during the search for other millenially persisting recording mediums like pen and paper, clay tablets, and stone structures.

The unadaptable predetermined decisions of the operating-system/application paradigm is worthless for the everyday person, who is the core of any people, the core of any culture. This is evident by companies creating applications for their own use, with the employee (an everyday person) making do with what is available while waiting for those applications.

An operating system is non-functioning without its applications, and developing an application is a tangent away from the flow of the moment. Without documentation, there is no hope of adapting someone else's program for the current moment. There is only choice of the decisions made by someone else, without opportunity for freedom of expression by the person choosing.

A core characteristic of the computer medium is that of immediate and exact duplication of any of its recordings, thereby the freedom for trial and dismissal without loss or corruption of the original version. That is the opportunity of self improvement with the freedom of saving and reviewing inspirations and influences, and sharing those with the community for discussion and accelerating cultural development.

# design is a collection of foreign decisions

Voting is choosing amongst a set of pre-made decisions. A decision is inherently presumed acceptable, regardless of whether it is desirable. Choosing from someone else's menu is choosing from someone else's comfort, perhaps a selection of someone else's abilities. A vote or a choice is at most the wiggling of a toe tag, nothing like personal expression as there is no opportunity for a personal decision.

Design is a set of decisions. Somebody else's design is somebody else's decisions. Ultimately, a design is a past, foreign to the present, an opportunity for reflection and release. The adaptation of a set of decisions is the conversion of it into a new approach, perhaps a setup for a eventual spin-off or even a prequel.

# computer displays: punchcard or GUI

Punchcard is a recording medium readable by computers and people, a type of memory card, t.i. a memcard. A punchcard can be a piece of cardboard with holes made from a holepunch tool, by either a person or a machine. The holes and the lack thereof are arranged along rows and columns of a grid, and can be detected by either machinary or a person feeling a card, or by a person visually perceiving the arrangement of the holes in a card.

A "graphical user interface" (GUI) is an oblique phrase for any object with drawings on it, essentially for only visual interpretation rather than physical or aural. For example, a sheet of paper, or a sheet of glass, or a grid of lights. Text and other shapes are drawn with lines or with dots, perhaps by coloring each square of a grid.

Obviously, shape is visibly noticeable only when there are at least two distinctive colors; corollarily, there are no distinctions with only one color. Text and other shapes can be drawn with only two colors available, commonly referred to as a foreground color for the most important areas and a background color for less important areas. Additional colors allow for more distinctions, thereby more variety of lines and dots for text and other shapes. Notably, an extraneous use of distinction is distracting or muddling.

A drawing, t.i. a graphical recording, using more than two colors on a grid bound by having only a single color per square (t.i. a dot) can record a greater variety than a punchcard using only one hole shape. Similarly, more than one physically distinguishable hole shape would increase the variety for a punchcard.

Notably, the raised dots of braille pressed into paper are the inverse of a hole, and provides such a variety potentially detectable by machines, too. Furthermore, the eight-dot version of braille is equivalent to the eight-bits of a byte, thereby suggesting bytes might be readily perceived visually and physically. The million symbols or characters of Unicode is one step away from that, each represented by one or more bytes, f.e. with the UTF-8 or UTF-32 formats.

A touchscreen is a transparent overlay for a graphical display, such as on top of a sheet of paper or on top of a grid of lights. The drawings of text and shapes, or the lack thereof, beneath the screen are coordinated with the same areas of the transparent screen overlaying them. The transparent screen detects physical touch, and those touches are related with the areas on the graphical display. While that physical action with the overlay is imitative of recording information on a punchcard, an unshapable graphical display remains unreadable physically.

HyperText Markup Language (HTML)
markup a CSS stylesheet
basic PDF 1.4
approaches for documenting binary files
file transfer, find, and grep
ssh key generation and use
notes about emacs: essentials and elaborate
installing emacs
email in emacs
ImageMagick command-line options for convert and mogrify (or magick as of 7.x)
Examples of ImageMagick Usage (6.x)