After 10 paragraphs of history we finally reach the point where Lipton explains the "general principle" behind both and the relation to computing science. This principle is

...do not rely on an action, but on the structure of the system. Make the default, a passive state, a safe state so that when the system fails, it gets to the safe state by default.

Lipton ends with three questions:

1. Could we, for example, make a system that is safe from worm attacks and uses a passive system?
2. Is there a formal model of passive vs. active systems that we could use to reason about whether such systems are even possible?
3. Is there any way to exploit the power of the passive methods used by Westinghouse and Otis to solve computer questions?

Define "safe", "passive", and "active". I must also ask what worm attacks have to do with software systems.

Modeling the Idea

In any case, these "passive" methods and systems are possible to implement.

Let us define a single function f and assume that the function modifies the state of the system. Thus, in the above example, there are two states: s₀ and s₁ (s is the set of all states). Execution of the function looks like this: s₀ -> f -> s₁.

If the function fails, then some action is taken to modify the current state to s₀. We will call that function g.

So if we have f and g in sequence, the state will change in the following manner: s₀ -> f -> s₁ -> g -> s₀

Modeling the Engineering Examples

We can model the two engineering examples using the above idea.

Let s₀ be the train at rest. Let the function f release the brakes and cause the train to move and change the state to s₁ (the train in motion).

Thus we have: s₀ -> f -> s₁

Failures can occur in f and so we must introduce g, the function that modifies the state to s₀. In this case, g will stop the brake release.

Thus we have the same thing as before: If f succeeds, then we are in state s₁; if f fails, then we execute g and return to state s₀. We can translate that to English: if the brakes are released (f is executed), the train is in motion (state is now s₁); if the brakes could not be released for whatever reason (f is not executed or has only partially executed), the train is at rest (state is set to s₀ and becomes "safe").

Conclusion

In software systems we define the rules and, if you will, the laws of physics. Therefore we can design and implement systems where "safe" states exist though the value of this depends on the system. The complexity of reverting or resetting state in a large system may be too intellectually difficult for us humble programmers to understand.

Lipton's second question, "Is there a formal model of passive vs. active systems that we could use to reason about whether such systems are even possible?", is answered: yes, "passive" systems are possible though I still don't know exactly what that mean. The third question is also answered, as others have pointed out. Some research has already been done in ideas related to the subject of the article such as fault-tolerant systems (also known as fail-safe systems) and self-stabilization. So yes, these "passive" methods are being used to solve computing problems.

So today I'm giving it a go. I downloaded moe via the GNU project's FTP server and installed it. The compilation was insanely fast, I think it took less than 10 seconds to get it all built and installed.

This blog post is a small tutorial (and a bit of a review) for using moe and is actually being written in it. I'm learning as I'm doing and this is usually the best way to learn anything. The manual for moe is, well it doesn't exist. When you first enter moe you are confronted with a blank screen and a title bar at the top of it.

The title bar lists:

• the command key being used (if any)
• the current mode of the text editor, either "I" for "Insert" or "O" for "Overwrite"
• the name of the file being edited
• whether it has been modified and needs to be save
• which line you are on
• which column you are at
• the time (in 12-hour clock with no AM/PM indicator)
• a helpful reminder telling you to press "F1 for help"

In comparison, nano only tells you the version of GNU nano that you are using and the name of the file. Nano also helpfully lists some commands at the bottom of its screen.

The first command key I used was of course "F1", the help key. Moe uses the function keys for saving files, loading files, undo and redo, the options menu, the buffers menu and some other things which I will get into as I come across them.

The second command key that I used was Ctrl+C. If the current file being edited is Modified, it will ask if you want to "lose your changes". If you press "n" meaning "No I don't want to lose my changes", it will save the file. I think this is better than asking if you want to save your changes. The way the question is posed is different and highlights the fact that you will lose whatever you were working on.

In terms of typing, moe hasn't gotten in the way at all. In fact, it has provided two useful command keys; Ctrl+Y which kills/deletes a whole line of text, and Ctrl+B which re-formats a paragraph by wrapping it at a certain column (I think column 72). The re-formatting is very useful when you're on a regular terminal. Right now I'm in the shell that you get before running any desktop system. The screen can only handle 80-character columns right now. You can set the column to whatever you like in the Options menu (accessed by pressing F10).

Okay, I just pressed F2 to save the file. It asked me for a new name or location for the file, but luckily it already provides the same name as before. So saving the changes is a matter of pressing F2 and then the Enter key. You can also save and exit moe by pressing Ctrl+X. After I'm done typing here, I'll definitely be using that, heh.

To load a file, you press F3. As soon as you open more than one file, they are loaded into separate buffers and then moe gives you access to the buffer menu. You can access it by pressing F11 and it lets you switch between the different buffers by choosing from the menu or pressing a number key. To get rid of the buffer, you press Ctrl+C.

So far moe is very easy to deal with, it all seems self-explanatory.

One thing to watch out for is the behaviour of whatever terminal you're using. The GNOME Terminal wouldn't let me use the function keys properly and the same was true of xterm. Another thing is the key bindings. They're kinda like Emacs's key chords, though not all of them are like that. There are four different prefixes for the key chords: "[", "O", "Q", "S". The first prefix is the most commonly used one, while the other three are used for special commands.

Here's the list and a few brief sentences about them. Some of them look useful and might help us programmers avoid re-inventing the wheel!

acct-6.5.1, The GNU Accounting Utilities are used for recording information about system usage by users. This would be useful for system administrators because they can see a history of past usage by user. The preface to the manual is awesome awesome. It begins with this line:

Way back a long time ago, Thompson and Ritchie were sitting opposite one another at the commissary, sipping coffees and discussing their evolving behemoth.

ccscript-4.1.2, ccscript3-1.1.7, GNU ccScript3 seems to be useful for creating scripting languages to use with C++ applications. Their website says,

GNU ccScript is a C++ class framework for creating a virtual machine execution system for use with and as a scripting/assembler language for state-transition driven realtime systems. The most common example of this is as the core of the scripting engine found in GNU Bayonne.

I haven't ever seen this in action but it sounds a little interesting.

coreutils-7.5, GNU Core Utilities are the standard GNU/Linux utilities. These are basically cd, ls, and other things like that. Obviously very useful for everyone.

Here are some utilities that I haven't even heard about before:

• tac: Concatenate and write files in reverse
• stat: Report file or file system status
• nl: Number lines and write files
• fmt: Reformat paragraph text, more specifically, "fmt fills and joins lines to produce output lines of (at most) a given number of characters (75 by default)". I usually use this type of function within Emacs (fill-paragraph) but it's nice to know that I can format whole files like this from the command-line.
• pr: Paginate or columnate files for printing
• ptx: Produce permuted indexes
• expand: Convert tabs to space. This is possibly the most helpful utility that I haven't heard of before! If someone's using tabs in their C, Java or Python files, I'll have to run expand --initial --tabs=4 to change all tabs at the beginning of the lines to 4 spaces.

freeipmi-0.7.12, GNU FreeIPMI is used for managing IPMI stuff. I have no idea what that means, so here's the excerpt from their homepage explaining it:

The IPMI specification defines a set of interfaces for platform management and is implemented by a number vendors for system management. The features of IPMI that most users will be interested in are sensor monitoring, system event monitoring, power control, and serial-over-LAN (SOL).

So I guess it's meant for managing large amounts of computers. Handy for system administrators for sure.

gengen-1.4, GNU Gengen (it stands for GNU GENerator GENerator) is like a template generator for C/C++. It's not like C++ templates or meta-programming, I think it's more like Lisp's macros. The variable names (the symbols of them if you will) can be substituted into a template. This is somewhat like the C pre-processor macros but I think it's a bit more powerful. I can't see myself using this though so I can't explain its usefulness any more than that. Read this section to see how Gengen could help you.

gsl-1.13, the GNU Scientific Library contains a collection of science-related calculation functions such as those for dealing with polynomials, vectors, matrices, sorting, etc. It is easy to see how this could of use to a large number of developers.

libsigsegv-2.7, GNU libsigsegv is a "library for handling page faults in user mode. A page fault occurs when a program tries to access to a region of memory that is currently not available". This library is useful for developers, in particular for systems developers.

libunistring-0.9.1.1, GNU libunistring is a C library for handling Unicode text and is useful for developers dealing with Unicode text. Note that this library isn't for providing translations, that's what GNU gettext is for.

moe-1.3, GNU Moe is a text editor with a file size of less than 500KB. It has a lot cool stuff in it even though it's so small. According to the README, there is no learning curve. Some experience with a text editor and a look at the README and apparently you're set to use moe. I'm going to download it and I'll see if it's a good replacement for nano and zile.

mtools-4.0.11, Mtools is utility tool collection for dealing with the MS-DOS filesystem. It has the basic tools needed to make use of the file system, such as a list directory utility, and another one for formatting a disk. This is useful for archival purposes or when dealing with legacy machines. I'm not sure recent versions of Windows use the MS-DOS filesystem for much ;-)

reftex-4.34, RefTeX is a package for automating labeling, referencing and citing other articles. It is used with LaTeX and BibTeX. I might have to check this out the next time I'm writing a paper for college/university.

sipwitch-0.5.7, GNU SIP Witch is a SIP server. Basically, "GNU SIP Witch can be used to build secure and intercept-free telephone systems". Again, this is useful for system administrators to know about, but isn't very interesting for me.

vc-dwim-1.2, vc-dwim is very useful for programmers because it keeps track of discrepencies between version control and ChangeLogs. The coolest thing is that it can commit changes to files that have been mentioned in the ChangeLog, the unmentioned files won't be committed. This makes it very easy to keep the version control commits and ChangeLog synchronized. I know I've forgotten to update the ChangeLog many many times.

xboard-4.4.0, GNU XBoard is a GUI for chess. It lets you use various chess engines to play. It handles a few different variations of the game too. I may check it out, I've been using eboard for a bit now.

zile-2.3.10, GNU Zile (which stands for Zile is Lossy Emacs) is a small text editor modeled on Emacs. It provides the same key-bindings and some useful commands. I've been using it as a replacement for nano and vi. The size of it is less than 500KB too.

HTML pages as containing structure and storing their contents in separate files. Easier for everyone to deal with and splits up your page into logical pieces.

Summary: INS and DEL elements re-discovered and used for version control. HTML document's version history kept within itself.

I re-discovered the INS and DEL elements in the HTML 4.01 specification last week and realized that it could be used for version control of an HTML document. The document itself could be a history of all the changes made to it. The key piece that makes this possible is the datetime attribute of the elements. If it is unspecified, then you don't know when the change was made which means all changes are blended together which makes this method of version control impossible. The W3C did the elements a great disservice by supplying examples in the specification that lack the datetime attribute.

So I hacked on some code that uses jQuery and JavaScript to go through a versionned HTML document and it applies changes from various days. You can see it in action here. You select a day and then click "Apply Changes Up Until This Date" to cycle through all of the changes made up until that date. Any text highlighted in red has not yet been deleted, it will be deleted at a future date. Any text in green was inserted as part of a change. Click "Apply All Changes" to have it cycle through all the versions and apply their changes. This will turn the HTML document into the latest version.

This was all a hack and not very well explained on the page itself. I'm starting to code a PHP script that will generate the HTML document in various dates to make it much easier to see the differences.

I was excited about this because it allows version control software to become aware of the structure of HTML. Instead of the software having to define new methods and data structures to save changes made to an HTML document, they can use the HTML document itself. For example, SVN and GIT store meta-data about the files in separate folders like .svn and .git. Using the INS and DEL elements, you can leave all the changes in the document; the meta-data is already in the document. The advantage is that you can move around the HTML document and it will always contain its own history of changes. You could have this by default and you wouldn't have to worry about saving files like this "my_document.html.version2" or "my_document.html.version3".

The trouble with HTML is that you need to wear a fucking biohazard suit to deal with it. You should and cannot be touching it directly, there are too many things that can go wrong. It's the same thing with XML. If you are writing it by hand, something will inevitably go wrong. You'll forget to close a tag, or one of the attribute values will be incorrect, or you'll just get confused by it all. We no longer use regular expressions to parse HTML and XML, we instead use proper parsers. Unfortunately we haven't gotten to that point with regular web design, the visual editors usually produce awful code.

I'll be creating a biohazard suit to deal with editing HTML that will have integrated version control. This is a spare time project, just like everything else I work on so don't expect too much too soon. Dealing with the versions and grouping the changes won't be difficult, the hard part is the user-facing portion where the versions will be creating by editing the document. I'm thinking of using an already existing HTML/rich-text editor like TinyMCE or whatever it's called.

Assembling An HTML Page Out Of Components

Summary: HTML pages as containing structure and storing their contents in separate files. Easier for everyone to deal with and splits up your page into logical pieces.

I hacked on another web junk project last night that separates content from structure. Current templating systems all will separate content/structure from the presentation layer but they don't go the one step further to make it all worthwhile. When I'm working on a website, I have portions of it where particular content goes in. I want to write out this content as plain-text, maybe with a few HTML tags like italics and bold inserted, and then have it inserted into a particular part of a webpage.

This isn't too hard, templating systems already do the find/replace stuff. However, I wanted the plain-text to be processed and HTML tags to be added to it automatically. Basically markup without me doing any markup. For example, I have a file whose content is used as a list. Every paragraph in the file is a list item in an unordered list. In another file, every paragraph should fit into an HTML paragraph tag.

The advantage for me is that if I have to collaborate with someone, I can send them the plain-text file and they can edit it without learning some fancy markup language or HTML. All they need to do is be able to write out sentences and paragraphs. Then I just drop the file back in and the proper content is generated. This is much easier than going through the file manually, looking for content differences and adding HTML tags.

This requires a biohazard suit for generating the HTML and for processing the plain-text content. The classes for processing the plain-text content are finite state machines: they read a line, check for some conditions and then do something. I'll post the code soon.

The hard part isn't inserting the content into the structure, it's finding out how much you want to split up the content. One section could be split into many different sub-sections and each sub-section could contain several paragraphs. Traditional CMSes (Content Management Systems) work on a page-based basis. They'll let you edit all of the content for the main part of the page, but they won't let you edit or split up that content into sub-sections.

Anyway, I'll have to write up some documentation and a tutorial on exactly how this all works. It'll probably be released under the GNU GPL version 3 license.

I hve been re-arranging my TODO lists using Emacs's Org-Mode and when I realized that it could calculate the exact hours taken for a bunch of tasks, I felt I should explore the rest of the Org-Mode manual and see what else I had been missing out on.

Org-Mode allows you to use relative timers which, it says, are useful for recording notes during a meeting or video viewing. I did not understand exactly how to use the relative timers, but it looks like they are like timestamps. Here's a brief run-down and example on how to use them.

Say you are watching a conference presentation on your favourite programming language, and you want to take notes. First, you would open up a buffer that is using org-mode and find the place where you want to put the notes. Then, you must start a relative timer by pressing C-c C-x . which starts the timer and inserts the current time (which is of course 00:00:00). This timer will continue to run even while you are in other buffers.

When an interesting point is made, or whenever you feel the need to record the time, you press C-c C-x . again. Then you just make your notes as quickly as you can!

Org-Mode also lets you pause the relative timer with C-c C-x , though I am not sure when you would want to use this. Maybe if the presenter is taking a break or if you were taking a break when watching a video?

Finally, to stop the timer, you press C-u C-c C-x , (which is basically just adding a prefix argument).

Here is a sample Org-Mode relative timer file:

* My Awesome Language (presentation)
0:00:00 Start of presentation
0:05:33 5 minutes in and we hit some interesting points
I don't know, Ruby as your Awesome Language? Ugh.
0:06:04 Oh good, he mentioned Python! But where's Lisp?!
0:06:26 jerk skipped over the Lisp slide...
I don't get why people *always* skip over Lisp :-(
0:07:35 Well that was a short presentation (thankfully)

That is the trouble with Emacs and its modes. There are so many useful functions contained that it is hard to use them all or to even know about them unless you read through the manual.