## Ubiquity commands in WordPress test

Filed under: Uncategorized
Created 01/19/2009 (8:34 pm) | Updated 05/13/2010 (5:49 pm)

This is a test post to see if I can publish Ubiquity commands with WordPress. Here are some real Ubiquity commands

I used the More tag so that the link rel tag only triggers Ubiquity when you view the post itself, not when viewing an aggregate of several posts.

Or would that be a bad thing?

## Ubuntu release quality

Filed under: Uncategorized
Created 11/19/2008 (12:01 pm) | Updated 07/24/2009 (9:33 am)

When I first installed Ubuntu in 2006, all my hardware worked out of the box.  It needed a few tweaks to run correctly, but it was much easier to get running than other distros I had tried.  I was very pleasantly surprised, and Linux became my primary desktop for the first time.  My computers are still configured to dual-boot with XP, but I barely ever boot into it.

With the last few releases, though, I’ve felt that after “upgrading” my system, it actually gets worse. There are lots of bugs and regressions, and I wonder how this can possibly be an official “release”.  Intrepid was the worst so far: my video card stopped working, my keyboard’s function keys started locking up the screen, session saving doesn’t work, sound system is misconfigured, …  These are exactly the kind of headaches that led me to abandon Linux in the past and go back to Windows.  When I upgrade my computer, I expect the upgrade to fix problems, not cause more.

Is every Ubuntu release worse than the last?  To see if it’s just my own personal experience, I looked through the release polls on Ubuntu Forums and combined them all together into a little HTML percentage bar graph.  The green bar is for the percent of users who found the release “worked flawlessly”, after either an upgrade or clean install. Yellow is for “few things to fix, nothing serious though”. Red is for “many problems that I’ve not been able to solve”.  (The poll questions are the same for each release, and have 1,300 to 5,500 voters each.)

It’s pretty clear that my experience is not unique:

Feisty (1,387)
 47% 23% 30%
Gutsy (5,479)
 22% 44% 34%
Hardy (4,250)
 23% 46% 31%
Intrepid (1,343)
 18% 34% 48%

Almost half of Intrepid users experienced “many problems” that they have been unable to solve.

You can see from the original results that the experiences for upgraders and first installers are roughly the same, proportionally.  (47% of Intrepid upgraders had serious problems, while 48% of first-timers had serious problems, for instance.) I’d speculate that this means that the main difference between people who have problems and people who don’t is the compatibility of their hardware.

I don’t know much about the technicalities, and haven’t followed the politics behind release cycles, but it seems that something needs to change in the priorities.  I don’t understand why a product would be shipped out the door as a “release”, when it has major bugs like this that were known in advance.  Isn’t that what betas and release candidates are for?

I’ve been told that I should wait a few months before upgrading, so that when I do, the bugs have been fixed.  But then… what’s the point of calling it an official release?  Why don’t you delay the release until those bugs are fixed?

I’ve been told that I should stick to LTS releases if I want fewer bugs, but I had plenty of problems with the Hardy upgrade, too.  The graph shows that Hardy was only marginally better.  Some even said the LTS release was “much more buggy than Gutsy or any other previous release“.

I’ve been told that Ubuntu’s release schedule is a response to Debian’s long delays between releases — that a rigid six-month schedule keeps programs like Firefox and OpenOffice up to date, but as a consequence we have to pay the price of a less stable system. I don’t understand why these are so intertwined.  I can download the latest bleeding-edge versions of software titles from getdeb.net and run them just fine on my system; why can’t the “flagship” titles be kept up-to-date, while the low-level subsystems are kept as stable as possible?  If I’m using the latest Firefox beta and it crashes, it’s no big deal, but if a less-technical user upgrades their computer and the video card or wireless card stops working, that’s a deal-breaker.

Also, why not keep the release candidates to a rigid schedule, but delay the actual release until the bugs are fixed? Users who just can’t wait for the upgrade can subscribe to the RCs instead of the actual releases, while normal users who want to use their computers instead of debug them can wait until the real release.  Maybe this is what’s supposed to happen with the betas and releases?  It’s not working.

## Add a “From:” field to gnome-screensaver locked screen

Filed under: Uncategorized
Created 11/18/2008 (9:24 pm) | Updated 11/25/2008 (12:43 pm)

Just a small idea for improving gnome-screensaver.  When the screen is locked, other people can leave messages, which show up as libnotify pop-ups.  It’s not obvious to the person leaving the message how it will appear, though, so I think we should add a From: field to encourage them to sign their name.  Otherwise you might not know who left the message.

Currently it looks like this:

and the pop-up looks like this:

I think we should add a From: field like this:

and the corresponding pop-up could look like one of these:

After proposing this on Ubuntu Brainstorm, I found an independent request on Launchpad, so I’m not the only one.

## Canon refuses to support Linux

Filed under: Uncategorized
Created 09/09/2008 (2:46 pm) | Updated 11/22/2009 (3:07 am)

I’d been wanting a scanner for a while, and kept procrastinating.  Eventually I got fed up with myself and drove to Staples and bought a Canon CanoScan LiDE 70.  After getting home, I remembered why I don’t make impulse purchases at stores.

The scanner seems decent, but does not work in Linux, making it useless to me since I switched to Ubuntu.

I wrote to Canon several times asking them to support my OS, and they refuse:

Thank you for your inquiry. We value you as a Canon customer and appreciate the opportunity to assist you.

Unfortunately, Canon does not write or support any drivers or software for the various Linux operating systems. The driver development information is proprietary information, kept at Canon Japan, and is not available to the public. I apologize for any inconvenience this may cause.

Please let us know if we can be of any further assistance with your LiDE
70 scanner.

Thank you for choosing Canon.

I told them that they don’t need to write drivers themselves; they can be written by the Linux Driver Project for free.  All Canon has to do is provide the proprietary communication protocol information, which will not be disclosed, but they refuse to do anything to help:

While considering the desire to provide the best possible support for Canon‘s products, Canon USA must make decisions on which products to provide driver support and platforms to provide drivers for.  Currently, Canon USA has decided to support only the Microsoft Windows and the Macintosh operating systems.

Canon USA has announced no plans to provide or assist in supporting the Linux platform with the consumer line products.  We understand, and sincerely apologize for any frustration this may cause if your are using an operating system Canon USA does not support.

We sincerely apologize for the difficulties and inconvenience this reply may cause. As a Canon customer, your satisfaction with our products and service is very important to us. We are dedicated to doing our best to provide support of our products, warranties, and customers with the support options we have available to us.

We remain committed to gaining your confidence and business once again. If, in the future, you reconsider your decision regarding your Canon scanner, we hope you will provide us with another opportunity to serve you. Until that time, we hope any replacement products perform to your expectations.

Thank you for contacting Canon.

Blah blah standard form response.  Guess I won’t make the mistake of buying their products again.

It looks like there might be hope, as Jürgen Ernst is working on a SANE backend for “CanoScan LiDE 600F”, which would support the LiDE 70, too.  I can understand not wanting to waste employees’ time on a tiny minority OS, but it’s ridiculous that users have to completely reverse-engineer their products’ protocols in order to use them, when manufacturers could very easily make this information available for us to write drivers with at no cost to them.

## Kensington VideoCAM

Filed under: Uncategorized
Created 09/09/2008 (2:26 am) | Updated 10/05/2008 (11:21 am)

This is super old-school and likely no one has any use for it anymore, but I once mirrored the Kensington VideoCAM webcam Windows 2000/XP drivers from this site, which are no longer available online:

The Unofficial Source for Kensington VideoCAM Support
By Orson Teodoro [horsie619@aol.com]

http://www.geocities.com/trypt0/videocamsupport.html

The text of the website itself is available on the Wayback Machine, but the driver files are not.  So here are the files I have, including a mirror of the original directions and driver list. Links to driver files I didn’t mirror are struck through. (Sorry.)

## Making Wine colors match Ubuntu themes

Filed under: Development
Created 08/03/2008 (4:57 pm) | Updated 06/28/2010 (8:52 pm)

Inspired by attempts to make Wine‘s theme match the Human theme in Ubuntu, I tried to write a script to scrape colors from Gnome and apply them to Wine automatically, so the themes match no matter what theme you’re using in Gnome. (Of course it would be best to have actual theme support, but current implementations are uselessly slow.  Matching the color scheme is a good start, and might be a useful component of real theme support anyway.)

Here on Github

As of this edit, it works pretty well for some themes, but not others.  I’ve been told that my first all-in-one attempt was in vain, since each GTK engine is free to use GTK’s colors in whatever way it wants, so scraping from GTK directly as I am doing will only work some of the time.  To really do it correctly, I guess I would have to make separate color mappings for each GTK engine.  That doesn’t sound like fun…

Making the fonts match is also important, which isn’t covered by the script.  You can see in my screenshots that I’ve set the winecfg fonts to match Gnome, but I can’t figure out how to set the others. If you know how to set the fonts, please tell me.

### Screenshots

It works pretty well for Clearlooks themes:

Blue Clearlooks theme with Tango icons

Ubuntu Human theme

It (surprisingly) works pretty well for Ubuntu Studio’s theme:

Ubuntu Studio theme

At first I thought it wasn’t working for Darklooks, since Notepad looks nothing like Gedit, but then I noticed that certain GTK windows do look the same as Wine windows, so I have no idea what they’re doing with Darklooks:

Darklooks theme

There is apparently no way to scrape the title bar color from GTK (I’d have to go into each engine to figure out which colors they use), so I just have it using the selection color, which matches Clearlooks themes decently.  It’s a compromise anyway, since the drawing/shading/gradients of the title bars are completely different:

Ubuntu Human theme with full Wine windows

An example of an engine that doesn’t work is Resilience.  They use a different set of colors for the menus than the ones I am scraping, so the menu colors are not only mismatched, they are unreadable:

Resilience theme

### Wine color values

Although I wasn’t immediately successful with the script, I did figure out what all but one of the color values in the Windows/Wine registry do, which I couldn’t find in any concise list elsewhere. (In Windows registries, "name"="data" pairs are called “values”. See Windows Registry on Wikipedia.)

Some of the Windows registry colors I could find online, but others I had to reverse engineer by changing the registry to obvious colors and restarting the Wine software/Windows. I’ll explain them all here so you don’t have to go through the same work. There are 31 possible color values, which are the same between Wine and Windows XP registries, but have different names in the winecfg configuration dialog (which is called Configure Wine in the Gnome ApplicationsWine menu under the Desktop Integration tab).

I’ve since discovered the CSS2 system colors, which map suspiciously directly to a number of the Windows colors (with slight spelling changes, of course) allowing you to produce them in your browser (theoretically).  So it looks like the web browsers have to implement the same functionality as my scraper script.  I’m curious to know how they do it.   (Poorly, I’ve found.  The colors are scraped by nsLookAndFeel.cpp, which exists in different versions for each toolkit.)   I’ve included them in the table, too, for completeness.   (These were deprecated in CSS3 and replaced by the “appearance” property.)

Wine/Windows registry Wine Configuration Item CSS2
ActiveBorder Active Border ActiveBorder
ActiveTitle Active Title Bar ActiveCaption
AppWorkSpace Application Workspace AppWorkspace
Background Desktop Background
ButtonAlternateFace Controls Alternate Background
ButtonDkShadow Controls Dark Shadow
ButtonFace Controls Background ButtonFace
ButtonHilight Controls Highlight ButtonHighlight
ButtonLight Controls Light
ButtonShadow Controls Shadow ButtonShadow
ButtonText Controls Text ButtonText
GradientActiveTitle Active Title Bar Gradient
GradientInactiveTitle Inactive Title Bar Gradient
GrayText Gray Text GrayText
Hilight Selection Background Highlight
HilightText Selection Text HighlightText
HotTrackingColor Hot Tracked Item
InactiveBorder Inactive Border InactiveBorder
InactiveTitle Inactive Title Bar InactiveCaption
InactiveTitleText Inactive Title Text InactiveCaptionText
InfoText ToolTip Text InfoText
InfoWindow ToolTip Background InfoBackground
Menu Menu Background Menu
MenuBar Menu Bar
MenuHilight Menu Highlight
MenuText Menu Text MenuText
Scrollbar Scrollbar Scrollbar
TitleText Active Title Text CaptionText
Window Window Background Window
WindowFrame Window Frame WindowFrame
WindowText Window Text WindowText

In Wine Configuration there’s one more option called “Message Box Text”, but you can’t change its color.

CSS2 also includes the following “ThreeD” colors.  I’m not sure how they are supposed to differ from the Button colors:

Dark shadow for three-dimensional display elements.
ThreeDFace
Face color for three-dimensional display elements.
ThreeDHighlight
Highlight color for three-dimensional display elements.
Light color for three-dimensional display elements (for edges facing the light source).
Dark shadow for three-dimensional display elements.

In Wine/Windows, some of these colors only appear in certain configurations, so they were hard to figure out. Here are the functions of each, as near as I can determine:

#### Buttons and 3D objects

• ButtonHilight — Outermost button highlight, also used for text shadows on grayed-out buttons
• ButtonLight — Inner lit up edges of buttons, usually set to the same color as ButtonFace
• ButtonFace — Button background
• ButtonText — Color for 3D object text and other glyphs (Maximize symbol, drop-down arrow, etc.)
• ButtonShadow — Inner shadow of buttons, also used for grayed-out button text
• ButtonDkShadow — Outermost shadow of buttons, usually black
• WindowFrame — The glow around the widget that is currently in focus

These colors are also used for every other 3D object, like tabs, borders, drop-down boxes, etc.

I still can’t figure out what “ButtonAlternateFace” does. This is used by the registry in Windows XP and in many Wine themes online. (By default, no colors are defined in the Wine registry and it just adopts a Microsoft-esque color scheme, but they are defined in an actual Windows XP registry with the default Windows Standard Classic theme.) As far as I can tell, the “ButtonAlternativeFace” value seen around the web is just a misspelling.

#### Window decorations

The equivalent names for active and inactive windows aren’t instantly obvious in alphabetical order:

Active window Inactive window TitleText InactiveTitleText ActiveTitle InactiveTitle GradientActiveTitle GradientInactiveTitle ActiveBorder InactiveBorder

There are actually two different ways to display menus; 3D menus and flat menus. This is set by flipping one of the bits in the UserPreferencesMask value in [HKEY_CURRENT_USERControl PanelDesktop], as described in Tony Schreiner’s WebLog. I had no idea. I don’t know why flat menus aren’t the default in Wine. They seem better.

• Menu — Background for menus, also background for menu bars in 3D mode
• MenuBar — Background for menu bars. Not seen with default 3D menus
• MenuHilight — Selected item background Highlight for flat menus. Not seen in default 3D menu mode; Hilight is used for this, instead.
• MenuText — Menu text

#### Selections

• Hilight — Background of selected text, background of selected menu item in 3D menu mode
• HilightText — Selected text itself
• HotTrackingColor — Hover color for single-click navigation, like links or single-click mode in Windows Explorer

Hot tracking vs selection

#### ToolTips

• InfoText – Tooltip text
• InfoWindow — Tooltip background

#### Backgrounds

• AppWorkSpace — Background color of multiple-document interface (any program that lets you Tile and Cascade sub-windows inside of a main window)
•  Background — Background color of the Windows desktop (or virtual desktop in Wine)
• Window — Background color of notepad, for instance

#### Scroll bar

• Scrollbar — Background of scrollbar

This is only visible in a few applications. I see the color in Firefox, for instance, but not in Notepad, IE, MS Word, system tools, or anything else in Windows. I don’t get it.

The scroll bar buttons and handles are just colored the same as any other 3D button, but the background of the bar is just a gray in most apps, no matter what you set this value to.

In Wine, it colors the bottom right corner of Notepad, between the scrollbars, but not the scrollbars themselves. I’m not sure what this means.

#### Text

• WindowText — Text in Notepad, for instance
• GrayText — Grayed out text in windows, like labels for unavailable widgets

## Freeform object selection lassos

Filed under: Computer interfaces
Created 06/29/2008 (9:54 pm) | Updated 08/07/2010 (10:44 pm)

Currently, to select objects in a GUI, such as icons in a file manager, you use the mouse to draw corners of a rectangle (called a “bounding box” or “rubber band” in the Gnome Human Interface Guidelines).  Usually, though, the objects you want to select aren’t contained within a single rectangle. To select them all, you have to hold down the Ctrl key while drawing several different rectangles. For instance, you might want to select a block of icons, but not a few in either corner, because of the way they are ordered, which requires you to draw 3 or 4 rectangles.

It would be easier to just outline the things you want.  Instead of rectangles, it should be possible to select objects by drawing a free-form lasso around them.  This is more intuitive, and will be easier to grasp for the less technically-inclined. After watching many people interact their computers, I suspect the majority aren’t even aware they can use the Ctrl key to combine multiple selections. This would let you select all the files with a single swoop:

As shown, a line would be drawn back to the starting point to complete the selection, so you don’t have to draw the entire outline.  The line that you draw should be smoothed as you draw it, on the order of the size of one icon, so as not to be messy, since we don’t need any more precision than a single icon anyway.  It should also be possible to “backtrack”; if you draw backwards within a certain width of the line you already drew, it will erase it, so as to de-select something you accidentally went around.

You could even select disjoint groups of objects with a single mouse movement, for a group of files that wraps to a new line, for instance:

Objects will be considered selected if their centerpoint is inside the lasso. Alternately, the lasso’s shape could be redrawn to go around objects as you draw (shrink-wrapped), but this might be less intuitive:

Here’s a mock-up in Processing.js to play with.  Since you can draw sloppily and still select things, it’s actually faster to use the lasso in most situations than rectangles, as well as being more intuitive.  It’s especially good for touch screens and styluses.

Obviously this idea of selecting multiple objects with a lasso instead of rectangles is applicable to more than just Nautilus File Manager.

Filed under: This site
Created 06/21/2008 (8:40 pm) | Updated 08/09/2008 (5:00 pm)

So I’ve been trying out WordPress, but having lots of problems. Here are the two most recent:

• Not being able to insert the text “convert (from” — even with other characters in the middle — without getting a 403 error.  Not being able to insert images without getting a 403 error.  I had to create a .htaccess file in my wp-admin directory.  Support thread here.
• Not being able to insert special characters without them being converted into question marks on pressing Save.  I had to convert the mySQL database to UTF-8, which was created as Latin encoding by default.  This screwed up all my posts, but I made backups first.  Support thread here.

This really isn’t working out the way I expected it to.  Spending much more time maintaining WordPress itself than I would have spent maintaining a bunch of hand-written web pages.

## BitScope

Filed under: Electronics
Created 06/17/2008 (12:14 am) | Updated 05/20/2013 (11:25 am)

Note: “BitScope DSO” is the software interface for the BitScope USB oscilloscope.  This is totally different from the “Bitscope” package used to monitor digital audio in JACK Audio Connection Kit.

I have an old 2-channel analog oscilloscope, but it’s not very convenient and doesn’t have any storage capabilities, making it really difficult to measure transients or things that happen long after the trigger.

I looked around at different options and decided a USB scope would be nice to have.  Since I’ve started using predominantly Ubuntu Linux at home, but Windows XP at work, I wanted something that would work in both operating systems.  The BitScope seemed to be what I wanted, but is quite expensive, with even the cheapest pocket analyzer at $475. (My old analog scope was less than$50 on eBay.)  With the help of a saved eBay search for “bitscope”, though, I eventually ended up finding one for 1/3 the normal price.

As is often the case with deals like this, the unit didn’t work when I got it.

### Repair

The seller said it worked fine for him, so I poked around some more.  I tried it in Windows and it didn’t work there, either.  I went to Gnome System Log (/var/log/messages), and saw this among the messages it displays when I plug it in:

Jun  1 23:18:24 Inspiron kernel: [53398.974351] hub 1-0:1.0: over-current change on port 1

Aha.  It’s drawing too much current from the USB bus and getting shut down.  This is the sort of thing I develop at work, so I should (theoretically) know how to fix this.  I found a compatible DC power supply (12 VDC, 800 mA, 2.5 mm center positive) and tried it with that, and it worked!  It also worked when I first plugged it into the external supply, then plugged in the USB cable, and then disconnected the external supply.  So it seemed like an inrush current problem rather than a short circuit/bus power problem.

(According to the USB spec, devices cannot draw more than 100 mA in an unconfigured state, except for a brief inrush current spike, but the amount of excess charge during that spike is limited to 50 µC.  In other words, you aren’t allowed to put more than 10 µF across the VBUS line to ground.  A lot of USB device manufacturers ignore these requirements, and most computers don’t care, but my Dell Inspiron 8600 seems to be especially picky.)

The BitScope website emphasizes the fact that it’s “open design hardware”, but there were no schematics for this unit on their web site, and the eBay purchase didn’t include a manual.  So I wrote to the company and asked for help.  They were very helpful, going so far as to scan in a manual and convert it to PDF for me:

The company told me there’s a “slow-start” circuit, but it’s more of a “delayed start”.  While plugging in USB, the PWREN pin on the USB FIFO (FT245BM) is brought high immediately.  This keeps the PMOS switch IRF7314Q open, so no current can flow from VBUS into the rest of the circuit.  After initialization, the PWREN pin snaps low, opening the PMOS switch and connecting 47 µF directly across VBUS to ground.  My computer doesn’t like this much current, and presumably shuts down the FIFO, evidenced by the PWREN pin going high again about 8 ms later.  (Remember that I am just eyeing this up on an analog scope with no storage ability.  Thankfully, Linux was kind enough to continually re-initialize the USB port, trying to connect and failing over and over again, so I didn’t have to keep plugging and unplugging the USB cable manually while holding the probes against the relevant pins.)

After realizing this, I decided I should try to make the FET open up a little more slowly so the current into the cap is not so high.  So I connected a 1 µF cap (time constant of 10 ms) from the gate of the FET to ground.  It worked!  But when I looked at the system log, it was still showing the over-current error.  In fact, it looked like it got the over-current error, shut down, re-initialized, and then started correctly, probably because the cap was still charged from the previous attempt.  Then I realized what I had done.  By putting the cap to ground, the FET was held closed during startup, so there was still an inrush spike while plugging in, instead of after initialization. So I connected the cap between the gate and VBUS instead:

Now the gate is pulled up instantly along with VBUS at plug-in, but when PWREN goes low, the FET gate voltage is slowly dropped down, so it doesn’t open fully until after ~10 ms.  Now it works on bus power with the laptop, and doesn’t complain about over-current at all.

### Software

After getting the electronics working, I started up the DSO software.

You have to download and install kylixlibs3-borqt along with the BitScope DSO software or it won’t work.  I used the BitScope-maintained kylixlibs3-borqt_3.0.2bs-1_i386.deb package from the download page.  Other .deb files are available from the kylixlibs SourceForge site, but I don’t know if they work for this.

So then it continually popped up the .csv import screen, indicating that it can’t connect to the hardware.  Eventually I figured out that I had the wrong thing entered in the configuration dialog.  Press the SETUP button and put /dev/ttyUSB0 in the IP Address or Port box under the Setup tab.

I had tried just ttyUSB0 alone and it wasn’t working.

### Launcher

After getting it working, I made a Launcher for the main panel.  Right-click Applications, click Edit Menus, go to the Other menu, press New Item.

I got the real icon out of the Windows version, which you can download directly here:

There’s also a scope icon on Rachel’s pages.

### It works!

My body has a built-in signal generator:

## Abolish the saving of documents

Filed under: Computer interfaces
Created 12/24/2007 (5:06 pm) | Updated 08/31/2008 (1:57 pm)

### The status quo

• Documents are created and saved, then opened, modified, and saved again to the same filename.
• While opened, a document can be modified. Many programs have an undo button to revert to one or more previous states. New modifications can then be made, and the document saved and closed. (When you close the application, these undo revisions are lost.)
• In programs like Microsoft Office, the changes you make to a document are incrementally saved as temporary files, so that if the application crashes, you can usually retrieve most of your work since you last saved it. (When you intentionally close the application, these temporary files are lost.)
• Some programs (wikis, Google Docs, Adobe Acrobat, Microsoft Word, OpenOffice Word Processor) greatly smooth collaboration by allowing changes to a document to be tracked under the name of the person who made those changes, so others can see what was changed and the differences between each contributor’s revision.
• When you’re working on a document, and take a short break to start working on something else, you minimize or otherwise hide the application that the document is open in.
• When you’re working on a document, and take a long break to work on something else or turn off the computer, you save the document and close the application that the document is open in. You then re-open the application and document manually when you want to work on it again.

Aren’t these all really just variations on the same theme?

### Continuous archival

In the future, I imagine that the whole concept of saving documents by hand will be abolished, and a new concept that takes all of these related ideas into account will evolve. The sooner we can push for this, the better.

Instead of manually saving files, closing applications, and re-opening them to continue working on a document, the state of the program and document will be transparently, continuously saved. Every time you make a change to the document or its settings, that change will be recorded, allowing you to access all previous revisions of the document. “Revision control”, “undo/redo”, “track changes”, “recovery files”, and “autosave” will all be combined into the same thing.

Instead of pressing Save, you might press something like Mark, Milepost, or Commit; something to indicate that this is a version you consider stable and that you might want to return to. (This is kind of like the difference between previewing and saving in a wiki.) Minor revisions might still be saved, too, but when you want to go back to a previous revision, you’d be able to focus on these major “mile markers”. (You could also go back and remove or add these “milepost” tags to specific revisions after the fact.)

Conscious maintenance of the files and program state will no longer be necessary. These are really just system-level details derived from historical needs that the user should not have to worry about. All the user should be concerned about is the state of their work.

### Revision trees

One problem with traditional undo commands is that you can’t undo an undo. Say you’re using a graphics program, and you carefully draw a red star, undo it, and then draw a blue circle instead. Then you change your mind and want the red star back. Too bad. When you undid it and made a change to the document, the previous redo action was lost forever. You’ll have to draw the red star from scratch again, since your revisions can’t branch.

Ideally, you could still press Undo or Revert, but the application wouldn’t just be saving the previous edits in memory and going back a step; each change would be saved permanently. You could “close” an application and re-open it, and still undo that color correction that didn’t look quite right and redo it from the original image data. But the change that you reverted would be saved, too. You’d be creating a fork in the revision history, a branch in the revision tree, and if you undo something and make another modification, you can still go to the thing you undid, too. You could change your mind and keep both the blue circle and the red star.

If you want, you can fork a particular revision to an entirely new name. You might want to make a February newsletter based on January’s, for instance, and keep January’s as a separate file.

### Collaboration

Edits that you make to the file would have a personal identifier attached to them (hostname/username? personal URN?), and you could optionally share parts of the revision history with other people, so that when they modify the document, you can view the differences between each version and see who made each edit.

This would also be useful when a script, package manager, or other system agent makes a change to a system file, as the change would be logged under the script’s name, date, and time, just like a human collaborator. When I (or something else) changes a system configuration file and it hoses my system, I will be able to revert to the last version or see what change caused the problem, without requiring me to make intentional backups manually or rename files.

This is good for sharing files because it allows collaboration. This is not so good for sharing files because:

• All those revision diffs take up space and bandwidth
• Revisions might contain things you don’t want other people to see

So I imagine that the revisions would be tagged “private” by default (more on tag-based filesystems later), and when you publish a document or send a file to someone, you would have to consciously choose to send the revision information as well. The default would be to send only the most recent stable revision (another place where the Commit button comes in):

You’re sending a file, but you’ve made further changes to this document since you last pressed Commit. Are you sure you want to send this version, or do you want to include the latest changes, too?

### Setting things aside

I mentioned being able to undo a change to a document even after you’ve closed the application it is in. But then, why would we even need the concept of “closing” an application? If we’ve been successful in removing the distinction between “save/close/open” and “undo/redo”, then “close” and “minimize” are just variations on the same action: “put aside for now”. The only difference between these actions is the way the processor and memory handles them. So let’s get rid of this system-level distinction, too.

When you close an application or minimize it, what are you really doing? You’re just putting it out of sight while you work on something else.

I imagine that the system will become much more document-centric. I imagine that documents, disparate in format but related in concept, could be grouped into “projects” with tags, and you’d minimize/close the entire project to work on a different project, and then return to the project later. Instead of “minimizing” something, you’d be filing it away for working on at an indefinite later time. Instead of a taskbar that shows currently-open applications, you’d have a “project bar” that shows most recently worked-on projects. As you open something new, the oldest will “fall off” the end. (More on project-based workflow later.)

It already seems like a program that hasn’t been touched in a while gets “filed away” on the hard drive. If I come back to an application after hours spent doing something else, it’s apparent that the state of the program has to be loaded from the hard drive instead of memory, which was being used for other things. It “feels” as if the program’s progress is being reloaded from more permanent storage. So all this memory management and such could be handled automatically, so that there’s effectively no difference between minimizing an application for a few hours and closing it for a few hours.

### Implementation

I’m not thinking too hard about how this grand scheme would be physically implemented; just thinking about what I would like to see from the user standpoint.

In the time between now and this future, we’ll have to deal with things like system files, which can’t really be automatically saved in an intermediate state. You really want to make the changes, triple check that there are no errors, and then save. (This is the major reason I’m afraid to use Scribes, for instance.) Automatic saving to the “original file location” doesn’t work here, though revision control would still be useful. This is another place where the Milestone or Commit button would come in.

Maybe the revision diffs would be stored in a separate physical file anyway. (Maybe the file system could even make this system compatible with older programs that don’t support it directly, by creating virtual folders for each file with the previous revisions represented as datestamped files, and the filesystem would assemble the older revision from the diffs on the fly when asked to load them.)

On the practical side, (bigger?) files will be saved using delta compression, so that only the current reversion and differences between previous revisions actually take up space on the drive. But hard drives are cheap, and will just get insanely cheaper over time. (Today, the average American can buy more than 50 billion characters of storage for an hour of labor.) So the space incurred by something like this for plain text, formatted text, HTML, and similar documents is completely negligible.

I’m sure there are algorithms for generating diffs of non-text files, too. Rsync can do this sort of thing, though it’s optimized for transmission over the network. Something optimized for dealing with disk sectors would probably be more efficient here. Really big binary files are rarely changed by the user, anyway. People doing full-length video editing have other ways of dealing with this stuff. I’m thinking more along the lines of text documents, spreadsheets, photos, drawings, mp3 tags, system configuration files, code, and so on. Of course the exact details would have to be optimized by someone who actually knows what they’re doing.

I’m sure all of this has been proposed in some form or other. It’s inspired by wikis, which have the revision control and multiple editors feature. Some allow reverting to previous versions, which allows undo/redo forking, though this isn’t clearly shown as a revision tree. Google Documents implements a lot of this now. I’m not really a programmer, and I’ve never been directly involved with CVS or subversion or anything like that, but I get the impression that these systems do a lot of this, including the revision trees.

But now let’s apply this to our own computers, in an intuitive usable way. All of these different concepts should be combined into one and applied to the documents and applications on my computer’s native interface that I use every day. The file paradigm on personal computers hasn’t really changed in decades.

« Previous PageNext Page »