2013

December 2013
  December 29
    Using #opmlFeed to override default
      I need to be able to override the automatically generated feed URL, so that people can confidently subscribe to the feed for the blog. The goal is to get the docs to settle down, so we can get into some kind of a routine.
      So the URL for the feed is going to be this: http://fargo.io/blog/rss.xml
      With the #opmlFeed directive I can tell the CMS to use this URL instead of the one it generates pointing into my dropbox folder.
      #flProfile "true"
    Watched folder feature
      Choose the Settings command in the System menu at the right end of the menu bar. Click on the CMS tab. There's a new checkbox that allows you to enable the "watched" folder.
      Screen shot.
      In a few seconds a new folder is automatically created in your Small Picture folder called watched.
      Copy an image into the folder. Wait a few seconds (as many as 11 or 12).
      A dialog should appear with the URL of the image.
      You can use it anywhere you would use the URL of an image. It doesn't even have to be in Fargo.
      People who use the OPML Editor for content management will recognize the feature.
      They don't have to be images. They could be MP3s, PDFs, whatever.
      "cheesecake"
  December 27
    Quick checklist for using GitHub repos
      1. Carefully follow the instructions on this page.
      2. When you set up the folder for your repo, make it a direct sub-folder of the Fargo app folder in Dropbox. This is important. It must have the same name as your repo.
      3. There's a new directive, #siteFolder, that allows you to tell Fargo where to store your files. This is how I set it up for the Kim Parker site: #siteFolder "scripting.github.io/kimParker/"
      4. When you're ready to try it out with Fargo content, render the whole site with the Render All Pages command in the File menu.
      5. Verify that the pages were rendered into the sub-folder of your github folder.
      6. In the GitHub client, click on Commit & Sync button. Screen shot.
      7. View the updates on your website.
  December 16
    New Fargo settings
      There are two new settings in Fargo, the default file name and file suffix.
      They are initially index.html and .html, but the server system you use may require you to use different values. However for most applications you can leave them as-is.
      You can access the settings dialog from the System menu in the right edge of the menu bar in Fargo.
  December 15
    Playing with templates
      As part of the slow software movement, I'm taking my time with a new template I call medium because it is inspired by the template used on medium.com. There's a big picture at the top of the page, a title and a sub-head, followed by the body of the post.
      The idea is that it's supposed to look good no matter what picture you put up there. And the bigger the better. And it should look good on a mobile device. And all the parameters come from the attribute hierarchy, so you can have global defaults, and override them on specific pages.
      Anyway, enough hype, here's the beef...
      ##### Pointers
        The template is in this outline.
        This is the outline for my test site.
        Here's an example page about Dick Van Dyke in Mary Poppins.
        And another example -- about Bargniani, a player on the Knicks.
        I was having so much fun I did another story about Clara Peller, the Where's The Beef lady.
        Then Adam posted a picture on Twitter, I thought it would make an interesting page.
      The text on the pages of course is purely silly. It's the container that's interesting. ;-)
  December 3
    Major overhaul of Fargo CMS
      I recognized the pattern, there was spaghetti starting to envelop the CMS code.
      This happens when you add special cases by adding boolean parameters to routines.
      That happens because when you wrote the high level code you didn't fully understand the problem. This al ways happens. The question is did you leave yourself the room in the schedule and with regard to potential breakage to actually rebuild the code so it correctly achieves its purpose? Too often you can't go back and re-engineer it, and you live with the bad construction. Then the code is fragile its whole life, so you don't build new layers on top of it, or if you do they're either inefficient or missing obviously valuable features.
      I decided to rebuild this time. The problem was confusion over how and when index files would be built. And how to link to them in the Next/Prev links.
      What I realized was the code was optimized for minimizing the amount of stack building. When I got to that point in the rebuild, I added a cache, so the upper level code could be totally simple and natural. It worked!
      Now the question is can I use the software for its intended purpose? I was able to do that before. Can I still do that?
November 2013
  November 30
    Welcome to the new Fargo CMS
      There's a lot to tell in this story, and much of it is still being written.
      Basically here's the plot outline:
        In December of 2012, I started a new project that became Fargo.
        Fargo was patterned after the outliners I created at Living Videotext and UserLand in the 1980s and 90s. The user interface was a gesture-for-gesture clone. The reason I wanted this is because I depend on outliners, but the operating systems my outliners ran on are not as reliable platforms as they once were. Fargo runs in web browsers, and therefore on all operating systems that support the web.
        We also developed a server component so we could use Fargo to write blog posts and documentation.
        It worked! Fargo is a great outliner. I use it all the time. I'm using it right now to write this.
        Then disaster struck. The programmer I was working with on the server quit. The software wasn't finished, and as I wrote at the time, it was largely a black box to me. I tried to develop with it, but it was ridiculous. It ran in a one-off server environment, and there was no debugging, and it was in a language I was far from expert in (JavaScript). Those are too many disadvantages, so I decided to release that software under the GPL, and look for another route.
        I had an immediate problem because my blog, Scripting News, was running in Trex, and I was writing it with Fargo, and I didn't want to give that up. So I quickly wrote a Frontier tool to generate the site from Fargo.
        Then I had an idea! Why not do what I had done in Frontier using JavaScript instead, and design it to run in the browser? I took a look at it, and tried out some ideas, and it seemed possible. A really bizarre idea, because we don't usually think of browsers as a platform for running a CMS! But why not?
        It worked! I say that as if it just happened overnight. It didn't. It took 1.5 months of everyday work. I didn't want to do this again. I had written this code in various contexts probably a half-dozen times since 1996. I know where the pitfalls are. I know that if you do it too quickly you create a tangled mess that's impossible to evolve. Instead, I did it slowly and carefully, with a lot of testing.
      Now, I want to say a few things to Fargo users, so that expectations are set correctly.
        This is not Trex. There are two big things missing, both by design: Rules-based outline rendering and dynamic serving.
        Instead of using outline rules for automated formatting, we use Markdown. It's not as powerful, but it's easier, and much more popular. It's like embracing JavaScript and Bootstrap and Font-Awesome. By using Markdown integrally, and it wasn't added as an afterthought, the CMS was built around Markdown, we have to solve the problems in a way that will make sense to a lot more people.
        Dynamic serving can still be done, either using this CMS in another form of deployment, or using the GPL'd Trex. But right now, I want to fill in the pieces we need for static content, served via commodity systems like Amazon S3. I want robust sites that don't hit scaling walls, like we did with Trex. Using this method means it will be more complicated for users right now, but it shows us all, not just me, very clearly, what's needed to complete the puzzle. A piece of software that's easy to build, but that as far as I know, no one has built yet.
October 2013
  October 13
    Fargo 1.29
      Interesting feature request from Jeff Triplett in a comment on a Scripting News blog post. He says it would be cool to be able to tell Fargo to notify a server whenever an outline was saved. We already do that for Trex-hosted websites, so it seems it would be easy to add a way to notify any server. At first the UI will be bare-bones, but if it goes somewhere we can add it to the Settings system.
      How it works
September 2013
  September 19
    Fargo 1.27
      Trashcan icon in arrowpad
        Chuck Shotton noticed there's no way to delete stuff in the arrowpad interface. Now there is.
        But be careful cause you need a keyboard to undo. Still need to figure that out.
        Screen shot of the new feature.
      An internal "virtual" keyboard
        This change has no user interface at this time, but if it works it will get one.
        The keyboard in Fargo is now virtualized. This means that there's a layer between the physical keyboard presented by JavaScript and the one used by the outliner. So we should be able to make this something the user can modify.
        If it works here, I'll also add it to the Concord open source release.
        Coders who want to see what the key definitions are, have a look in this JavaScript file.
        Also, not all the mappings are done yet, there are keystrokes that are caught at a higher level, in the Fargo app, not in Concord. They have to be accounted for as well.
  September 9
    Fargo 1.25
      Cmd-keystrokes for Expand and Collapse
        An oversight, there should have been keystrokes for Expand and Collapse.
        These keystrokes go all the way back to ThinkTank for the Apple II, circa 1981 or so. Pretty ancient stuff.
        Cmd-comma expands and cmd-period collapses.
        The mnemonic for this is that the symbol over the comma is < which looks a bit like expanding. And > looks like collapsing (even though the meaning of the characters is opposite).
        As a bonus, inherited from Frontier, cmd-shift-comma toggles expand and collapse state of the bar cursor headline
      Experimental feature: The Arrow Pad
        The arrow pad is designed to make reorganizing and navigating in an outline easy on a tablet like the iPad.
        It's not finished, there's still tweaking to be done, but I wanted to get an idea of how it works for people before going further.
        To access the arrow pad, choose the command from the Outliner menu.
        Screen shot below.
        There are two buttons and four arrows.
        The leftmost button says either Navigate or Reorg.
          If it says Navigate, the arrows move the cursor.
          If it says Reorg, the arrows reorganize the outline.
        The arrows move in the indicated direction, when you click them.
          They are only enabled if movement in the indicated direction is possible. They are structural, so left moves to the parent when navigating, or moves the bar cursor outline out a level in
        The rightmost button says either Expand or Collapse.
          The setting depends on whether the cursor is on a headline that is expanded or collapsed, and it says what the button will do if you click on it.
        When you're in text mode in the outline, the arrow pad automatically goes into Reorg mode.
  September 7
    Fargo 1.24
      Pretty sure I found and fixed the problem that was causing some files to become encrypted without the user deciding to encrypt them. If you were experiencing the problem, and found it reproducible, please let me know via a comment here, whether this fix worked or not. Thanks! :-)
    Fargo 1.23 -- Reorg menu
      The Outliner menu was getting too long to fit on a laptop screen.
      Solution: Create a new menu with the reorganization commands separated from the other outliner commands.
      There are six commands in the new Reorg menu:
        Move Up
        Move Down
        Move Left
        Move Right
        Promote
        Demote
  September 6
    Fargo 1.22
      There's a new checkbox in the right margin that shows you whether or not the active outline is encrypted.
      It's only visible for editable outlines, and if you've set an encryption password.
      The checkbox is still present in the Outline settings dialog because there are circumstance where the right margin is not visible.
      Update: 1.22a fixes a bug in the code that displays the checkbox. It was reporting a file was encrypted even when it was not.
    Fargo 1.21
      It's possible that the keystroke problems in the with Firefox with Fargo's Find and Find again commands are cured in this release.
      In previous versions, when you pressed Cmd-G, Fargo would do its Find again thing, as it's supposed to, but the browser would also try to do a Find of its own.
      I got some help from the developer of keypress.js, David Mauro, and implemented his suggestions in 1.21.
      If you had problems with Firefox please say if it works or not (and of course if any new problems are introduced, speak up as well).
    Fargo 1.20
      I thought I had Find working but it didn't work for Ron Chester's outline.
      Turns out he had lots of headlines with the same created attribute.
      As noted, the Find command was assuming that this attribute could be used as an identifier, but clearly that wouldn't work in this case, so I rebuilt the Find command without making this assumption.
      I've asked Ron to check it out and let me know if the new version works. ;-)
  September 5
    Fargo 1.19
      Fixed a bug in Find again, where it would always loop back to the top in certain circumstances. The error was ridiculous, and I went looking in the wrong direction for it, so it took a lot longer than it should have to fix. Still learning how to do this programming thing. ;-)
      One caveat, the way Fargo tells when it's reached the cursor headline is by looking at the created attribute on headlines as it's searching. If the cursor headline does not have a created attribute, we add one. Under normal circumstances it's put there automatically by Fargo as you enter text into your outline, however if you copy/paste from another outliner into Fargo, or import via OPML, it's possible headlines won't have this attribute.
      It's possible if you have two headlines with exactly the same created attribute that the Find command could get confused.
  September 4
    Fargo 1.18 -- Find wraps around
      In its first release Find would stop when it reached the end of the outline. If what you were looking for was above you, it wouldn't find it.
      Now when it reaches the end, it starts over at the beginning.
    Fargo 1.17 -- Find and Find again
      Find and Find-again
        This feature has been waiting until we could figure out how to capture Cmd-F and Cmd-G, instead of having them be caught by the browser.
        Perhaps now we have a way to do that. I'm using a package called keypress.js. It works on my machine, Chrome on the Mac.
        So for this release the question is this -- when you press Cmd-F (or Control-F on Windows or Unix) do you get a dialog asking for a string to search for?
        When you press Cmd-G does it do another search from the cursor position?
        Thanks to Tal Safran for the clues. ;-)
      Compatibility
        There may be issues in some browsers with the keystroke invocations, if so, use the menu commands.
        Works well in Chrome and Safari, not so great in Firefox..
      Find command documented
        The docs are in the Using Fargo section.
      Invisibly...
        I moved all the files that were outside of outliner.smallpicture.com into that bucket. It's neater and cleaner to have all the stuff in one place. There might still be a few stray files, I'm going to keep an eye out for them and move them as well.
  September 3
    Trex 1.09 & Fargo 1.16
      The <%byline%> macro in previous versions included a timestamp.
      I think this was a mistake. The byline should just contain the author's name, linked to the author's website, as provided in the OPML file.
      There was another problem. The link we used in building the byline is the link to the home page of the outline being edited. In Fargo, however, we have a better value, the profile URL value on the You tab of Settings. Prior to Fargo 1.16, however, this was not being saved to the OPML file. Now it is, in a new head element, <ownerProfile>. This value is available as a Trex macro as <%opmlOwnerProfile%>.
      I updated the list of macros to include the new opmlOwnerProfile macro.
August 2013
  August 29
    Fargo 1.15
      Fixed a bug reported by Jeffrey Kishner.
      How to reproduce
        Open the Outline Settings dialog (File menu), turn on encryption, click OK
        Activate another outline. Open Outline Settings, the default value for encryption will be on, which is not good. It should default off.
        In Fargo 1.15 it does default off.
      Diagnosis
        Reason this was incorrect, this is the first new outline-level setting since the advent of the Outline Settings dialog, so this situation has not happened before. There's now a place in the code where new settings are initialized.
  August 28
    Fargo 1.14 -- Encryption
      With version 1.14 you can now encrypt outline files you edit with Fargo.
      http://docs.fargo.io/fargo/encryption
      I recommend starting with one file, to keep life simple, and put all the stuff in there that you'd like to keep away from prying eyes.
      You can't encrypt files you want to publish.
      Pick a good password. Don't store your password in your Dropbox folder. That would negate all the value to using encryption.
      Please report any problems. Provide screen shots and details sufficient that we can reproduce the problem. If we can't reproduce it, there's no way to find or fix it.
      If all goes well, I'll announce this feature on "Scripting News" tomorrow morning.
  August 25
    Reorganized the blogging docs
      I went on a hunt for docs I had written about Kim Parker's blog, and found a bunch of stuff, and probably will find more.
      What happened to the blogging docs is what happened to the Fargo docs -- there's too much of it to put on one page. It works better if we break it up into topics, so each one can expand to include all the information we have, without overwhelming the other topics, esp the beginner docs.
      So the blogging docs are now an index type.
      http://docs.fargo.io/blogging
      And the view-source docs are on their own page.
      http://docs.fargo.io/blogging/theViewSourceOfFargo
      This change means that some of the name anchors are gone, and therefore some links broke. But not many, and this change gives us room to grow, which we will definitely use.
  August 24
    Fargo v1.11 -- feed category support
      Added support for <category> elements in a blog's RSS feed.
      Documented in the blogging section of the Fargo docs.
    Trex 1.08
      There was a bug in the way flCommentsVisible att was implemented such that comments were always visible no matter how the attribute was set. Now we respect the attribute.
      The <%breadcrumbs%> macro always had a white background. This is not good. It shouldn't specify the background at all. The background-color style was removed.
      I added a breadcrumb trail to the default outline template, but it's hidden with a height of 0 by default. I've turned it on in the docs.fargo.io site with a bit of JavaScript that runs when the page loads. Having the crumb trails makes the docs site work a lot better, since things get pretty deeply nested and it helps to see what the context is when you arrive at a page through a deep link.
      The next version of the index type template will have a breadcrumb trail in it, implemented the same way. A bit of JS in the page can make it visible if your site needs a crumb trail. I believe most sites do not. But a large structured site like the Fargo Doc site definitely needs it.
      The first item in the breadcrumb trail is always Home. This makes it clear to the reader what the crumb trail is. It's especially confusing with first-level items, if the first item is the same as the menu title. It's just a word, hanging out there all on its own. If the word is Home, people have a chance of understanding what's going on.
    Docs redirected
      I figured out, with the help of some friends, how to do redirects on S3 files.
      So now the old files redirect to their new locations. This is good because I can update every bit of documentation now, all from Fargo. Much easier.
      Here's a list of the old URLs. Click on them to get redirected.
        http://smallpicture.com/fargoPress.html
        http://smallpicture.com/outlinerHowto.html
        http://smallpicture.com/fargoDocs.html
        http://smallpicture.com/fargoWorkgroup.html
        http://smallpicture.com/fargoRss.html
        http://smallpicture.com/trexRules.html
        http://smallpicture.com/trexDocs.html
  August 23
    Fargo 1.10 -- naming is more reliable
      We've had reports that the eye icon -- -- doesn't show up after someone goes through the outline naming process. So I'm doing a review of the code, and changing the sequence in which things are done to make the command more reliable.
      New defensive driving techniques
        If the user switches tabs while the outline is being named, we now apply the name to the correct outline.
        If the server returns the name undefined, we put up an error dialog and the outline is not named. Previously we would go ahead and set the link to http://undefined/ with predictably bad results. :-)
        We get the public URL for the outline before displaying the dialog. So we know before-hand that it worked. It's possible this is where it's failing for people. Previously it was done as the first step after the user clicks on OK or presses Return.
        We explicitly refresh the display of the icon chain after allocating the name.
      What it means that the eye didn't show up
        If you look in the OPML for an outline with a name, you'll see a <link> element in the head section of the document.
        The link element points to the home page of the outline when viewed through the web.
        If the outline's name is blue, the link is http://blue.smallpict.com/.
        Simply, if the link element is there the eye icon will show up, and if it's not there, it's because there is no link element in the OPML file.
    Reader 0.15
      New version of Reader strips <rules> from outlines before displaying.
      You may have to reload to get the new version.
      To test choose View in Reader in the File menu with an outline that has rules.
    Fargo 1.09
      Deployed the new docs site
        The Fargo and Trex docs and worknotes have been Fargoized. This means they are no longer managed in the OPML Editor. Part of the growing-up process for our new JavaScript world. In most ways it's equal to the old way of doing things, and in other ways it's even better.
        All the docs are on this site: docs.fargo.io.
        The blog has moved there (you're reading it now) and the RSS feed. Redirects should be in place so that no URLs break. If you find breakage, please report it in a comment or an email to the smallpicture-web list.
        The links to docs in Fargo itself have been changed to point to their new locations.
        If you want to look at the site in Fargo, choose Open by name in the File menu and enter howto.
      Two Trex issues
        In doing this project I found two problems in Trex that I was unable at this time to fix. My Trex skills are not up to the level of my Fargo/Concord skills.
          The archive type can't find your calendar structure unless it's at the top level of the outline. So I'm editing the Archive menu by hand.
          Redirect nodetypes should be more powerful. If the walk goes through a redirect node, the page we redirect to should have the remaining path added to the end. This way one redirect node can work for an entire site. My workaround was to use a tool in the OPML Editor to do the redirect.
        Observation: The reason Trex programming is so hard is that there is no ability to step through the code as it's running. If you're learning it, as I am, having the ability to watch it run makes a huge difference. Also makes it hard to fix problems. It's been many many years since I've not been able to step through code as it's running.
      Cleaned-up after previous fix
        In the last update, after closing the Edit Attributes dialog, we made sure that the visible display of comments agreed with the state of the isComment attribute. But we introduced a side-effect that caused an isComment attribute to be added that the user didn't add. While this didn't change the way the outline worked, it was annoying.
        The fix was to only set the display of comments, not the attribute, if the attribute was undefined.
  August 22
    Trex 1.05
      When rendering an outline, if a headline has an invisible attribute with the value true, the node is not displayed. However, the walk will find it (i.e. it's not commented out).
      This is useful when you need to place a redirect node somewhere but don't want it appearing in the rendered page.
      Redirect to a post on Scripting News
  August 21
    Fargo 1.08
      When we close the Edit Attributes dialog, update the display of the bar cursor outline so that the display matches the comment status, if the user has edited or deleted the isComment attribute.
      A new macro, <%version ()%> returns the current Trex version number, <%version ()%>.
  August 19
    Fargo 1.06
      The View in Reader command is back by popular demand.
      Closing the Edit Attributes dialog is now much faster. As your outline grew, it would get slower and slower. I have some huge outlines, and could really feel it.
      After you close the Edit Attributes dialog, the atts in the right margin update, reflecting any changes you made.
      Added a little margin on the left of the atts display it doesn't come so close to touching the outline area.
  August 12
    Fargo 1.05
      A hyphen in the Bookmarks menu now adds a divider line, as it does in menubar.opml.
  August 9
    Fargo 1.04
      There were a couple of bugs in the new Outline Settings dialog in the File menu.
      They have been fixed, and (fingers crossed) the dialog should now work in all cases on all outlines.
  August 6
    New "reader" macro for sharing JavaScript code
      A new macro lets you display the contents of an outline exactly as it would be displayed in Fargo.
        <%reader (opmlUrl)%>
      Example
        Here's an example of the macro being used to display the source code of a Find command I've been working on for the menubar, one that finds the next occurrence of a string in the active outline. You can copy the text from the outline below straight into menubar.opml.
        <%reader ("https://dl.dropboxusercontent.com/u/36518280/misc/codeExample.opml")%>
        It's very useful for code, but probably could be used for other applications.
      How to set it up
        Copy the outline text you want to share to the clipboard.
        Create a new outline, choosing New from the File menu.
        Paste the text into the outline. If there's an extra line, delete it.
        Chose Get Public Link from the File menu.
        Copy the URL to the clipboard.
        Paste it into a call to reader in this post, as shown below.
      The exact code
        <%reader ("https://dl.dropboxusercontent.com/u/36518280/misc/codeExample.opml")%>
      Tip
        It remembers how you have the outline expanded, so you can set it up so that it leads the reader to the parts you think they'll find most useful or interesting.
      Styles
        You can override the style choices I made by including CSS in your <%customStylesScripts%> glossary entry. I separated out the styles from the code so that your styles take precedence.
      Inspired by gists
        I saw Eric and Jeffrey using GitHub gists to display outline-based code in Fargo. It's a good idea, but gists are really for flat text and are not ideal for structured text. This should work better. :-)
  August 5
    Fargo 1.03 -- mostly housekeeping
      New Archive command in File menu
        If an outline is getting large, you may want to archive pieces of it.
        It works by converting a sub-outline into an include.
        An advanced feature
          This is an advanced feature and should only be used by people who understand includes, and have large outlines that are taking a long time to save. Most people don't need to archive sections of their outlines, at least not yet. :-)
        Archived material can't be edited
          Only archive sections that you don't need to edit, because you won't be able to edit them.
          For example, if you're keeping a blog in Fargo, you might want to archive July's posts at the beginning of August -- only if you're sure you won't need to edit them.
          Let me say it one more time -- no edits after something is archived. ;-)
        How to
          Put the cursor on the section of the outline you want to archive.
          Choose Archive outline from the File menu.
          Click OK to the confirmation prompt.
          Wait a few seconds.
          The bar cursor should change to an include node.
        Technical details
          The archives are stored in the archive sub-folder of your Fargo folder in Dropbox.
          They're stored in a calendar structure and given fairly cryptic names that are very unlikely to "collide" with each other.
      RSS feeds strictly chronological
        Previously the feed was built by traversing the outline in the order of display. So if the calendar structure appeared first, all the elements in the calendar would be added to the feed before any others.
        Now we do it strictly chronologically, so that if you add an item and move it outside of the calendar, it will appear in the feed in the order it was created.
        As a result of this change, any item that does not have a created attribute will not appear in the feed.
      Comments are now visible by default
        I would prefer if reading one of your posts, to be able to view any comments people had left without having to click on the "Show Comments" link. I imagine most others do as well. Previously comments were hidden by default. Now they are visible by default.
        If you would prefer that they be hidden, add this to the top level of your outline:
          #flCommentsVisible "false"
      New verb: string.hashMD5
        Implements the MD5 encryption algorithm.
        We're using the SparkMD5 package.
        Muchos gracias amigo! :-)
    Linking from img in Fargo
      In Fargo 0.98 we introduced the img attribute.
      A small addition -- if there's a url attribute on the same headline, we link from the image to that URL.
      You can see an example of this in the image of the O'Reilly Bootstrap book on this post.
    Changes in Bootswatch templates
      Background
        Luckily, I caught this advisory from Bootswatch about Bootstrap 3.
        At some point they're going to switch over to Bootstrap 3 themes in place of the current Bootstrap 2 themes. This is good -- at some point we will probably switch Fargo over to Bootstrap 3 as well. But we will probably always want to have a snapshot of their version 2 themes around, so I just made copies of them and made a change to the core Trex code to generate URLs to our copies instead of theirs. This was always the fair thing to do, there's no reason they should be paying to host files that we're using for our sites, esp since I'm now using a Bootswatch theme for Scripting News.
      The change
        Trex now changes all bootstrapTheme URLs that point to bootswatch.com to point to the location on smallpicture.com where we're keeping copies of the themes. So there's nothing you have to do to use the copies, that's automatic.
      What you should do
        There are two ways to reference the themes, by URL and by name:
          #bootstrapTheme "http://bootswatch.com/spacelab/bootstrap.min.css"
          #bootstrapTheme "spacelab"
        It's probably safer, long-term, to use the name instead of the URL.
        But for now, either way works. ;-)
  August 4
    Fargo's server-side defaults
      There have been a few requests for the default templates that Fargo uses.
      It seems reasonable, so I made a copy of the outline in my public Dropbox folder.
      https://dl.dropboxusercontent.com/u/36518280/misc/trexDefaults.opml
      However, this is just a snapshot and will not reflect changes to the templates.
    Using Fargo to build Scripting News home page
      Intro
        The home page of Scripting News, at scripting.com, is a static page in an S3 bucket.
        Before this work, I used a Frontier tool named threads.root to build the home page from an OPML file. Previously that OPML file had been edited with the OPML Editor, but a couple of weeks ago I made some small changes to the build script and was able to switch over to using Fargo.
        But I want the home page to have a Fargo look too, not just the story pages.
        At first I thought I'd make a few more mods to the threads.root tool to get it looking close to what the Fargo home page looks like, then I thought I'd try going in a different direction. Let's tweak up the look of the Fargo home page so that I can build the static home page just by reading the HTML from dave.smallpict.com and copying it to the S3 bucket.
        I'm going to narrate that work here.
      The steps
        I created a new glossary entry, <%customStylesScripts%> so I could override some of the styles in the template. I want to do as little to the template as I have to. (Note: In the end I didn't have to modify the template at all, I was able to do it all with CSS.)
        The links to the story titles should be black and bigger, so I added a style:
          .aBloghomeTitle {
            color: black;
            font-size: 1.8em;
            }
        I don't want the title and description at the top of the page, so I added a style to turn its display property to none:
          .divTitleDescription {
            display: none;
            }
        I want the at the bottom of the post to be black. I accomplished that by adding this style:
          .aWhenCreated {
            color: black;
            }
        I felt the body of the page needed to be a bit further down from the menu bar, so I added 25 pixels above it with this style:
          .divOutlineBody {
            margin-top: 25px;
            }
      Changes to the menu
        The previous version of Scripting News used tabs to provide access to several different sets of content.
          The most recent posts.
          The most recent links on my linkblog
          Links to the monthly archive.
          My personal river
        We don't yet have tabs in Fargo (I want them) but we do have menus, something the previous version of Scripting News did not have. So I'm going to use menu items to link to the linkblog, and the river. The monthly archive is a problem, because it wasn't being maintained since September 2012. So I'm going to link to it also, and set a goal of getting it up to date asap! :-)
        I also need to change the title from "Dave's Fargo Blog" to Scripting News.
        Add a description: "Scripting News, the weblog started in 1997 that bootstrapped the blogging revolution."
      Things that are not coming across
        There's the big Scripting News banner down the left edge. That was fine for a while, but I'm tired of it. Maybe it'll come back some day.
        The About dialog will be replaced by a web page.
      Things to think about
        Mirroring the story pages in the S3 bucket as well.
        Stuff that's in the head section of Scripting News
          <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
          <link rel="alternate" type="application/rss+xml" title="RSS" href="http://scripting.com/rss.xml" />
          <link rel="alternate" type="application/rss+xml" title="RSS/link-blog" href="http://links.scripting.com/rss.xml" />
          <link rel="alternate" type="application/opml+xml" title="Outline" href="https://dl.dropbox.com/s/v8e5gighrh8prpc/myPublicProfile.opml" />
          <meta name="generator" content="OPML Editor v0.75/threadsSuite.buildHomePage">
          <meta name="description" content="Scripting News, the weblog started in 1997 that bootstrapped the blogging revolution.">
        Linking to the feed
          Instead of linking to dave.smallpict.com/rss.xml, we have to link to scripting.com/rss.xml.
  August 3
    Working on Fargo's docs
      Of course I want to use Fargo to document Fargo.
      My dream has been to have a complete outline with all the docs in one place, and when new features come online, shortly after they're released, they'll be documented alongside all the other docs.
      A new Fargo user should be able to look at the menus, or the icons, and if they wonder how they work or what they do, the explanation should be a few easy clicks away.
      The work is coming along well, I think -- a testament to how good Fargo is at writing and publishing docs. It is very good, the best documentation system I've ever used. And maybe good enough to achieve the dream, which I've had for quite a long time. ;-)
      This is where the work is happening, although that's probably not the final URL for it..
        http://docs.smallpict.com/fargoFaq
      What's there so far is a very lightly edited version of what is in the Outliner Howto and Fargo Docs. The next document to incorporate are the Trex docs.
      BTW, you can keep up with the new stuff now with our feed:
        http://docs.smallpict.com/rss.xml
      Dave
  August 2
    Fargo 1.01
      menubar.opml in Firefox
        There was a problem in our implementation of menubar.opml that didn't show up in Chrome, but did in Firefox. Thanks to James Petry for spotting the problem and suggesting the fix.
      Unspecified fonts
        There was a problem in the new Outline settings dialog when displaying an outline with the font, size and/or line height not specified. We now check much more carefully for the presence of these value.
        There was also a report of the description not "sticking" but I have not been able to reproduce it here.
    Fargo 1.00
      1.00 ==> nothing special
        In the version numbering system we use, 1.00 means nothing special. It's just a serial number. It's no more earth shaking than 0.99 or 1.01. That said, I did try to do something special for this release, knowing that it would have this number.
      New command in File menu
        There's a new Outline settings command in the File menu that replaces the Set titles command. If you recall, the old command launched a dialog that allows you to set the short and long titles of an outline, as well as its description. These values are available when the outline is rendering through macros.
        The Outline settings command brings up a tabbed dialog. The first panel of that dialog is a replica of the dialog in Set titles, and does exactly the same thing. There's a second panel that lets you change the font, size and line height on a per-outline basis. I found that when I was editing code in menubar.opml, I wanted to use a different font from the one I use to edit blog posts.
        If you leave the font, size and line height blank, the defaults, set in the main settings dialog, will rule. (The main settings dialog is located in the System menu, the menu that's under your Dropbox username in the right edge of the menu bar.)
        Now each outline can have its own font, size and lineheight.
        And there's lots of room to add new per-outline settings, should the need arise. ;-)
        Screen shot.
    Experiment: Customizing the outline template
      People want to customize the default templates without having to replace them.
      CSS, scripting and the glossary make this possible.
      The experiment
        I've added a feature to the default template for the outline type. If it works, we'll add it to all the types. It will become a standard feature of the CMS.
        There's a new macro, <%customStylesScripts%> that's defined in the global glossary to be empty.
        The macro is referenced at the end of the <head> section of the outline template.
        You can add this to your glossary. Anything that's contained within it will appear at the end of the <head> section in all pages on that site that use the outline template. If you haven't done any template customization this will be most of the pages on your site.
      Example
        I've added this macro to the glossary on the docs site (the one you're reading now).
          If it worked this text will be green.
        It worked, because the text is in a span with a class of greenText, and my glossary entry defined greenText as green bold text.
        Here's a screen shot of the definition of <%customStylesScripts%> in my glossary.
      The plan
        If it works, I want to make this a standard feature of all the default templates, and welcome other template designers to include it as well.
      What do you think?
        Personally, I think it's a very neat solution, low tech, and makes a nice use of a feature we already have. The glossary is perfect for this application. But there may be problems, or ways to make it rock much more. Your comments and suggestions are welcome. ;-)
July 2013
  July 31
    More on the Fargo-Wordpress gateway
      Yesterday I wrote a post about the gateway that connects "Fargo" with WordPress.
      In that post, I suggested that it is possible to replace that gateway, which does not handle unicode characters, with one that does. It is possible, and for a reasonably skilled server programmer, not even very much work. In this post I want to outline the problem, at a technical level.
      The gateway
        It sits between Fargo and WordPress.
        Fargo is a JavaScript app running in the browser.
        We call the gateway with the jQuery routine $.ajax.
        In our gateway, we call WordPress through the MetaWeblog API, though a new gateway could use a different API, as long as it maintains the same interface to Fargo.
      The parameters we send with the request are
        postTitle: the title of the post.
        postBody: the body of the post.
        idPost: the ID of the post, 0 if it's a new post.
        weblogUrl: the URL of the WordPress blog.
        blogUsername: the user's username.
        blogPassword: the user's password.
      What the server does
        First, it gets the calling conventions for the blog using Really Simple Discovery to turn weblogUrl into an API address and a blog ID. It caches this result so subsequent calls won't have to go through the full RSD process.
        Then it makes a MetaWeblog API call to the WordPress server. Which call it makes depends on whether idPost is zero or non-zero. If it's non-zero it makes a metaWeblog.editPost call, if it's 0, it makes a metaWeblog.newPost call.
      What the server returns
        In all cases it returns a JSONP call, to a routine called getData, with a single param, a JSON struct, that contains several fields.
          link: points to the blog post.
          idpost: the WordPress ID for the post, used in subsequent calls to identify the post.
          error: its presence indicates that the call did not work. Its value is an error string that can be displayed for the user explaining the error.
        The content type of the response is application/json.
      Access-Control-Allow-Origin header
        Very important: the gateway must set the Access-Control-Allow-Origin header to fargo.io, so the browser will let Fargo call your service.
      Source code
        I'll provide source code for both the $.ajax call from Fargo and the gateway (written in UserTalk running in Frontier) as example-ware.
      Business
        I wrote the gateway in January in a couple of days. It took that long because I was unfamiliar with the way the $.ajax process works. It might still take a couple of days to get it up and running and tested and well-enough debugged so users can depend on it. It's the kind of code that takes two or three sessions to complete.
        To deploy, it will have to be on a publicly-accessible server. On Amazon or Rackspace that server would cost less than $100 a month to run.
        One server could easily support the Fargo community, even with a fair amount of growth. WordPress is at this time a fairly small application for Fargo. Of course if it worked better it might be a larger application. ;-)
        Doc Searls contacted me today, a Fargo user, who runs a WordPress blog, and he has an interest in making this work, and has offered (I think) to help coordinate.
        I would love to see this as a community development thing. I will show people how to configure Fargo to talk with a different server. We can make it a preference, to make it as easy as possible.
    Fargo 0.99
      New link for the worknotes site
        There's a link to the Worknotes site in the Docs menu.
        Since the site has moved, the menu item now links to the new location.
      Feed for worknotes
        It's also worth mentioning that because we're using Fargo to manage the worknotes, there's now a feed that you can subscribe to:
          http://docs.smallpict.com/rss.xml
        And because this all is in one place now we can have technotes too, and they will show up in the feed as well. :-)
      Fix for the Home icon
        Previously, the home icon (in the left margin) took you to the web view of the named outline. For example, if your outline was named george, the home button would take you to george.smallpict.com. This is usually the right answer.
        However, if you've used the domain attribute to map to a different domain, the web view of the named outline is probably not where you want to go, if your cursor is nested inside the headline with the domain attribute.
        So starting in 0.99, we first check to see if you're inside a domain attributed headline, and if so, we go there.
      New verb: op.getCursorUrl
        As its name implies, it returns the URL for the cursor, if it has one, otherwise it returns undefined.
        If the headline is within a page, we return the URL for the page, by shooting out to the summit looking for a node with a type attribute. When we find one, we return its URL. So it's not a precise verb.
        It's good for building redirects, static indices, stuff like that.
  July 30
    The Fargo-WordPress gateway is limited
      This has come up on the smallpicture-user mail list.
      I can give you all the info you need on this one, but you're probably not going to like it. ;-(
      In order for Fargo to communicate with WordPress, we have to go through a gateway.
      The software on this gateway is old. It does not understand unicode. So as long as you stick to 8-bit characters, you're cool. But when you use characters outside the 8-bit set, you can be pretty sure it will get mangled in transit.
      I can't do anything about this. However if someone else wants to create a gateway without this problem, I can make it so that Fargo can talk with that gateway. The person doing this would have to be a reasonably skilled server developer, and have a server to run the gateway on.
      If someone is interested in doing this they should contact me off-list, or if you prefer, post a comment here.
    Updated the default index template
      I had been tweaking the index template on dave.smallpict.com.
      I posted an RFC on the smallpicture-web list, but there were no comments.
      So I'm going ahead and making the switch. If all goes well the home page of this site will now be using the new index template.
    Housekeeping
      I'm going to start publishing worknotes over here. Will take care of bringing across the existing worknotes shortly.
      Update: The worknotes have been brought across. ;-)
  July 29
    Welcome to the Docs site
      This is going to be a combination of a blog and a documentation site.
      If everything works the way I hope it will.
      If not, I'm going to have some serious thinking to do! :-)
  July 28
    Fargo 0.98
      Shift-click on Eye icon
        If you want to get the URL of a page without having to go to the page, shift-click on the Eye icon in the left margin. A dialog will appear that contains the URL. You can copy it to the clipboard there. Saves a couple of steps. ;-)
      New img attribute
        You could, before 0.98, include an image in a Fargo blog post by adding HTML to the text of the post.
        Now it's a bit simpler.
          1. Get the URL of your image on the clipboard. If you don't have one handy, use this one.
          2. In Fargo, put the bar cursor on the headline that you want to attach the image to. The image will appear in the right margin of the post at the start of this headline.
            Note: The img attribute must appear on a line within the post, not on the title headline of the post.
          3. Click on the suitcase icon in the left margin.
          4. Add a new attribute by clicking the + button. It's name is img, the value is the URL you have on the clipboard.
          5. Click OK.
        When you view the outline in a web page, the image will appear in the right margin. It will also appear in the RSS feed.
      New settings, RSS features
        There are a couple of new entries on the You panel in the Fargo Settings dialog, for your Twitter and Facebook usernames.
        If you enter values for these entries, we will generate new elements in your RSS feeds that contain this information.
        This is an experiment. We're adding these features in the hope that other developers will use the information to add features to their products. Then we'll add some more stuff, and others will too, and hopefully RSS will improve and become more useful. It's been quite a while since people worked together on improving RSS.
      Viewing commented pages
        When you click the eye icon to view a page, we now check to see if it's commented. If it is, instead of taking you to the page, which will show up 404 not found, we ask if you'd like to uncomment it. Then you can click the eye icon again, after waiting a few seconds for the outline to save, and for the CMS to notice the change.
      Creating commented headlines with + icon
        In previous versions the headlines would be commented, but they weren't visibly commented. Now they are.
      Perspective
        As we're getting close to 1.0, I wanted to offer a few observations on where we're at and how it's going. ;-)
    Fargo 0.97
      Home icon in left sidebar
        Suppose you're editing a named outline and you want to quickly view the home page of the site. There's actually no UI for in prior to 0.97. You have to type the URL in the browser's address bar. This won't do! :-)
        Now the Home icon shows up in the left sidebar whenever the eye icon does.
        Click on it to view the home page of the side in a new tab/window.
      New command in Outliner menu
        A new Outliner menu command toggles between Render and Non-render mode. The single keystroke is Cmd-`.
        In render mode HTML entities are seen as they would be seen in a web page rendering of the content. This is possible because Fargo runs in the browser, which of course, naturally renders things as HTML.
        In non-render mode, the entities appear unrendered. So in image would show up in non-render mode as an <img> tag.
        This command worked in earlier versions of Fargo and Little Outliner, but it wasn't present in a menu, so was harder to discover.
        A screen shot of an outline in render mode, and a screen shot of the same outline in non-render mode.
      File menu changes
        Removed two commands from the File menu, View in Reader and Save as Markdown.
        Added these back as new scripting verbs, file.viewCurrentFileInReader () and file.saveCurrentFileAsMarkdown ().
        If you were depending on these commands, you can add them back menubar.opml.
        The reason for removing them is that there are now better ways to read content created in Fargo, using the web content management system. Having these commands in the menus were confusing for some users.
        See: Intro to Fargo Scripting.
  July 22
    Fargo 0.94
      In previous versions, if you had a page with type or method equal to markdown, it would render fine on the website, but its markdown nature would be ignored by the feed generator. That's now fixed.
      This post, as an example, has a method attribute of markdown, and it should appear with proper markup in the feed.
  July 20
    Fargo 0.93
      Before this release, the + icon required that the calendar be at the top level of the outline. Now, the calendar can be anywhere in the outline.
      Not a whole lot more to say about it. ;-)
  July 14
    Fargo 0.92
      One small feature, a nice thing to have, not crucial.
      If you put an insertedNodeType attribute on your calendar, then when you click the + in Fargo, that type will override the type you set in the Insert settings panel.
      You could also put the attribute on a month or a day. But it probably makes the most sense to put it on the year. You will have to remember to copy it to 2014 at the beginning of the next year.
      This allows you to maintain several blogs which may not want to use the same type for posts.
      Screen shot.
  July 12
    Fargo 0.91
      Rearranged the right sidebar.
      Removed links to docs that were already in the Docs menu.
      Moved the Save button up, and the Message of the Day down.
      Fargo will work better on shorter screens as a result.
    Fargo 0.90
      The equivalent of draft mode
        New setting in the Insert panel, allows you to tell Fargo to create new items with the + icon as comments. Comments will not be rendered by Trex, and will not appear in your RSS feed. This is useful if you're creating posts and don't want them to be viewed until they're finished.
        The workflow:
          1. Click + to create a new post.
          2. Edit your post until you're happy with it.
          3. Put the cursor on the top head in the post.
          4. Choose Toggle Comment in the Outline menu.
          When the outline is next saved the new item will then appear on the site, and will be included in the RSS feed.
        Screen shot.
      Redundant setting
        Removed the Autosave pref from the Advanced panel in Settings. There is a panel just for Autosave, so the setting was redundant.
    Trex 1.03
      New #directive
        For some of my posts I wanted the comments to be visible when the page is displayed, not hidden.
        So there's a new attribute, flCommentsVisible that says whether the comments are initially visible.
        Here's a post that illustrates.
        You can set it true after the fact, when a post attracts a lot of comments that you want people to see.
        Note: It's only effective if flCommentsHidable is true.
      A curiosity
        Whole version numbers like 1.0 mean nothing at Small Picture. Every time there's a new release we bump the version by 1/100th.
  July 2
    Fargo 0.89 -- Podcasting
      This feature is described in the Blogging howto.
  July 1
    Fargo 0.87
      Switched from Font Awesome 3.1 to 3.2.
      I took notes on the work on my Fargo blog.
June 2013
  June 30
    Fargo 0.86
      New entries in the Docs menu
        You can get to the Presentation and Blog post howtos from the Docs menu.
      The eye icon is a little smarter
        Suppose you're editing in a named outline, inside a presentation or a blog post. The cursor is on one of the subs, not on the top headline.
        Previously, if you clicked on the eye icon, it would erroneously take you to a rendering of the headline you are on.
        Now it shows you the post or presentation.
        Saves you from having to move the cursor just to view the document.
      Fixed a bug in encoding RSS descriptions
        The text of the description element in each item was double-encoded, so when you viewed it in a feed reader, you'd see the markup instead of the effects of the markup.
      Excessive saving bug
        In certain circumstances Fargo would save an outline on each change as many as 20 times. You would experience this as a sluggishness in the Save button in the right margin. Dropbox would experience an excessive amount of traffic for each save.
        The problem was that we were setting the <link> element in the OPML <head> section every time we saved the RSS. This would mark the outline as changed, which would force another save, marking the outline dirty, and around the loop we go. Since the saving happens asynchronously, eventually there would be a moment when the outline was not changed and it would stop the cascade. Now that it's fixed you get one save per change, and one build of the RSS feed. Whew! :-)
      The contents of the right sidebar is fixed
        It doesn't scroll as you navigate down through the outline.
        This is as it always should have been.
  June 29
    Trex 0.98
      flDisqusComments attribute
        A new attribute that's a carryover from the worldoutline software, it lets you selectively turn off comments without modifying the template.
        If flDisqusComments is defined and is not equal to "true" then the <%comments%> macro is the empty string.
        Here's a screen shot of the attributes of a headline with the new attribute set false.
      rssLink macro
        We now have a proper link to the feed embedded in every page on our sites.
        The new macro is called rssLink (). If there is a feed element in the head of the OPML, we generate the link. If the element isn't there, we return the empty string.
          <%rssLink ()%>
        It's meant to be included in the head section of the template. It's supported in the default templates.
      googleAnalytics macro
        A new macro generates the code to connect with Google Analytics.
        The macro takes one optional parameter, the account identifier.
          <script><%googleAnalytics ("UA-XXXXXXXX-1")%></script>
        It can also be called without a parameter, then we get the ID from the #googleAnalyticsID directive.
          #googleAnalyticsID "UA-XXXXXXXX-1"
        If both the parameter and the #googleAnalyticsID directive are not present, the macro returns the empty string.
        For the domain name, we use the Host header on the HTTP request.
      Disqus change
        The default groupname was scripting2. It has changed to smallpict.
        It's important to make this change as early as possible in the deployment of Trex. We should have made it even earlier.
        The upshot is that any existing discussions you have will now be empty. If you haven't had any discussions yet, there's nothing to worry about. However if you have some, and want to keep them, there is an easy fix.
        Add this directive where ever you need to use the old group.
          #disqusGroupName "scripting2"
        I needed to do this for dave.smallpict.com. I just put it inside the June 2013 branch. With July 1 on Monday, the site will automatically switch over to the new group.
        Of course you can easily create your own disqus group to allow the comments of your users to all be grouped together. Highly recommended! :-)
  June 28
    Fargo 0.85
      We've transitioned from running a community feed, to using RSS and hooking into the wealth of new RSS-consuming applications.
      We learned a lot from the experience with the community feed, but now it's time to complete the transition, so we removed the icon for the community feed in this release, and updated the Fargo docs accordingly.
      Also, there's a new howto that shows how to create a presentation with Fargo.
  June 26
    Trex 0.94
      New demo site
        We've started a new demo site, just for the purpose of illustrating Fargo features.
        http://kim.smallpict.com/
        It's Kim Parker's site, newly hired senior evangelist at Bloatware. She just got started with Fargo, and is using it to communicate with customers, the press and her colleagues at Bloatware.
        You can always see how she's doing it with the Open by name command in the File menu. Enter kim and click OK.
      Menus have menus
        Previously menus could only have links, but now they can have full menus.
        The top-level items in the menu structure are either links (as before) or they are menus if they have subs.
        Items in menus can have sub-text. If so, those are accessed through special URLs that Trex generates automatically. They behave just like other pages in Trex. Add a type attribute to make render the way you want. Or any other attributes. It goes through the normal rendering process for a page.
        You can have separators in menus. Just put a hyphen on a line to create a separator. Anything other than a single hyphen is interpreted normally.
        Items are disabled if they aren't links and don't have a type attribute.
      Bootstrap themes
        Thanks to Angelo for pointing us to the Bootswatch site and their incredible Bootstrap themes. This led to a new feature in Trex.
        Each of the themes on Bootswatch has a name, like flatly, readable or united.
        You can apply one of these themes to your Fargo site with the #bootstrapTheme attribute.
          #bootstrapTheme "readable"
        You can also provide the full URL to the theme:
          #bootstrapTheme "http://bootswatch.com/readable/bootstrap.min.css"
        We substitute the bootstrap.css file with the CSS file specified by the bootstrapTheme att. In a sense, the original Bootstrap CSS file is just the default theme. :-)
        Because you can put a URL in place of the name, you can use CSS files that you create yourself or get from others. A place for shared creativity.
      The numbering rule
        The new numbering rule allows you to put symbols, numbers or letters, in front of outline entries when they're rendered.
        There are several possible values: decimal, roman, alpha, harvard.
        decimal puts numbers, 1, 2, 3 etc in front of items.
        romanUppercase puts Roman numerals in front of items: I, II, III, etc.
        romanLowercase uses lowercase versions, i, ii, iii.
        alphaUppercase puts alphabetic characters in front of items: A, B, C.
        alphaLowercase puts alphabetic characters in front of items: a, b, c.
        harvard uses the Harvard outline conventions.
        Demos of the numbering rule are on the helloworld site.
      Comments in templates
        In previous versions comments would pass through Trex to the page. Now they are stripped before rendering, as comments should be.
  June 22
    Fargo 0.84
      The name attribute gives us a canonical way to refer to a headline that doesn't vary with its text. Prior to version 0.84 Fargo wasn't generating them, now it is.
      When you click on the Eye icon in the left margin, we take the text of the headline, remove blanks and some special characters and innerCase the text to form the name attribute.
      Net-net: Links won't break if you change the text of a headline.
    Trex 0.87
      Default Time Zone
        The default time zone is set to Eastern time.
        More specifically the attribute "siteTimeZone" defaults to the value "-4".
          -4 means 4 hours behind UTC.
        You can override this in your named outline with a directive at the top level:
          #siteTimeZone "-7"
      Bloghome and Markdown
        Markdown posts are now rendered correctly within the bloghome template.
        The markdown content of the post is wrapped in a DIV with class "markdown."
        Outline rules like list-space, outline-indent, outline-space and outline-space-before will not apply within the Markdown generated content.
          You'll have to use CSS and the wrapper class "markdown" to style the spacing and padding of elements within the Markdown content.
        Kyle
  June 20
    Fargo 0.82 loves RSS more
      Jeffrey Kishner points out that <rules> were being included in the RSS description element of Fargo's new feeds. That's not cool! Rules are meant to guide the rendering on Trex, but won't mean anything to a RSS aggregator. So in this release we take the rules out as we send the text out to RSS.
      The hits keep coming! :-)
    Fargo 0.81 loves RSS
      You can now use Fargo to post items to an RSS feed.
      Every outline has a feed, but the feed is only public for named outlines.
      The feeds are created in a new sub-folder of the Fargo folder called rss.
      You can access the feed through the named outline at /rss.xml.
      For example, my feed is at http://dave.smallpict.com/rss.xml.
      To add an item to the feed, click the + icon in the left margin. The main headline is the title of the item. The subtext forms the RSS item description.
      If you don't want the + icon to create feed items, you can turn this feature off in the Insert panel of Settings. Screen shot.
      You can cause any headline to be part of the feed by adding an isFeedItem attribute with the value true.
      PS: My feed is valid. :-)
  June 19
    Fix for missing eye icon
      Some people report named outlines for which the eye icon does not appear. We have a fix that works in some situations.
      The fix
        1. Open the outline in Fargo.
        2. Make it the current tab.
        3. Choose Name outline in the File menu.
        4. Enter the name of the outline. Ignore the message that says the name is taken.
        5. Click OK.
      What should happen
        1. You should get a confirmation dialog saying the name has been assigned.
        2. When you edit the outline you should see the eye icon.
  June 18
    Fargo 0.80
      With this release Fargo is coupled with a new content management system called Trex, which was also developed at Small Picture. This means that you can publish documents and presentations from Fargo. And it's easy! :-)
      How to publish
        1. Open a named outline.
        2. Create a new headline in that outline, something like My first story.
        3. Write a paragraph or two indented beneath the headline.
        4. Put the bar cursor on the top headline, and click the suitcase icon in the left margin to edit attributes.
        5. Add a type attribute, with the value outline. Click OK.
        6. Click the eye icon in the left margin.
        You should see a simple lovely page with your words on it!
      Viewing an outline
        If you enter paragraphs under a headline you get something that looks like a story, but if you enter indented headlines, you get something that looks like an outline.
        Here's an example that looks like an outline.
        And here's one that looks like an essay.
      Make a presentation
        1. Open a named outline.
        2. Enter a main headline, something like My first presentation.
        3. Enter a series of slide titles underneath, Slide 1, Slide 2, etc. (Or be creative!)
        4. Under each slide title, add a few bullet points.
        5. Put the cursor on the main headline, and click the suitcase icon to edit attributes.
        6. Add a type attribute, with the value presentation. Click OK.
        7. Click the eye icon in the left margin.
        Here's an example presentation. This is what it looks like as it's being edited in Fargo, and the OPML for the presentation.
      Profile change
        The special headline with the text profile is still displayed when we display the top level of your website, but instead of using Reader to display the outline, we use the content management system.
        For example, here's my profile outline.
        Because the headline must be exactly profile in order for it to be recognized, you'll need a way to specify the text that's displayed in place of the headline text when the page is rendered. You can do this with a #text directive just below the headline.
        Here's a screen shot that illustrates.
      Where we go from here
        We want to make a great environment where writers, designers and programmers work together.
        There's a lot more that Trex can do. We plan to provide simple Fargo-based interfaces for much of it. But we're going to show the features slowly, one step at a time.
      Lifting the hood
        If you're a web developer or designer, you may want to dive right into Trex, if so here are the docs. But we want to emphasize that if you're a writer and non-technical, you don't need to understand what's in the engine. It's our job to make this simple for you, a job that we take very seriously! ;-)
      Participate
        When you write something new feel free to post a link in a comment here. :-)
        We want to see how you're using the new stuff.
        Questions and comments are most welcome.
  June 11
    Fargo 0.78
      A few touch-ups for the + icon.
      1. When we generate the top level headline for the year, instead of setting the type to calendar, we set the icon to calendar.
      2. If there's already a type of calendar on the year headline, we remove it. Any other type, we leave alone.
      3. When creating a headline, the type goes on the headline we create, not on its parent. This way when we generate a web index for a calendar structure, the document boundary will be where users expect it.
  June 6
    Fargo 0.77
      More improvements to the + icon
        A new Settings panel, Insert, lets you change the level of insertion and determines the type of headline it creates.
        Screen shot of the new panel.
        If you choose to create one note per day, then when you click on the + icon, Fargo will navigate to the headline for today, creating it if it doesn't exist. It creates a new empty headline just below, enters text mode, so you can start typing.
        If you don't choose one note per day, we create a new entry with the current time every time you click the + icon. This is the way it worked before version 0.77.
        We added this option because we felt that for some people one note per day was enough.
        You can also enter the name of a type that will be automatically assigned to each new item it creates. If you're in one-note-per-day mode, the type will be put on each day. Otherwise the type will be attatched to each time entry.
        The default value of this setting is outline. If you don't have a strong reason to change it, we recommend that you don't.
        This feature is here to connect with the new server software we're working on. :-)
  June 3
    Fargo 0.75
      This release improves the big + icon at the top of the left sidebar.
      Recall that it adds a new headline to a calendar-structured outline. At the top level is the year, below that the month, then the day, then a time stamp, and then a place to add your notes. Here's a screen shot.
      If you use the + icon to add to your outline you'll get a neat structure organized in reverse chronologic order, much like a weblog.
      What's new
        1. You can now place the calendar anywhere at the top level of your outline. It no longer has to be the first item, but it must be at the top level.
        2. The first time you add an item to the calendar with 0.75, we'll add a type attribute to the year with the value calendar, but only if it doesn't already have a type.
        3. The icon for the calendar type is, of course, a calendar. ;-)
      How to try it out
        To try it out, if you have a calendar in one of your outlines, move it, and try adding an item. It should find the calendar in its new location.
  June 2
    Fargo 0.74
      First a little story...
      I was watching the game last night
        There was an incredible basketball game on last night. As you may know from reading Scripting News, I have been enthusiastically following basketball all season, and now we're in the semi-finals, and the Indiana-Miami series has been incredible. Last night's game was probably the best game all season.
        At the same time, the community feed is going through what I think of as growing pains. I've been developing community software for a long time, going back to the early 80s, and I've started lots of these things. Some of them grow up to be huge, like blogging and podcasting, and some don't. I learn a lot either way. But I don't need to learn things three or four times. Or more! One would hope. :-)
        The community feed, as it was set up, is exactly the same as an unmoderated mail list or discussion group. The fact that we're all using an outliner to write for it doesn't matter. It goes in a predictable direction. There's a sense that this is the center of everything, the place where decisions are made, the authority of everything. It isn't that. But it feels that way.
        Over time that tends to push away the people we want to hear from most, the people who use our product but for their own work. They're not trying to do our work, which is to develop and enhance an outliner product, Fargo. But over time that's where these things tend to go. This community is growing very quickly, so the focus has shifted a lot sooner than I thought it would. I think to some extent, btw, that I am responsible for this rapid shift. My presence there serves as a lightning rod for people to give me feedback, and I even ask for it. I shouldn't, and I wll try not to in the future. I want to participate less, and get out of the way and let the users speak.
        Anyway, during the game, a couple of well-intentioned outlines were posted that said "Pay attention to me now or else!" But I didn't want to do that, because I was watching a game, and I needed some time to think about what to do next, and I honestly I had had a few beers by then, and the last thing I wanted to do is get involved in the community feed. So, this is what I did:
          1. I set the enabled flag for the group to false.
          2. I went back to watching the game.
          3. I thought some more about where I want to go with this.
      The Community Feed is now moderated
        That means that someone from Small Picture will read everything that's posted to the feed. If it's primarily feature suggestions about one of our products, we'll read it and it will influence our product decisions. Can't say we'll do everything people ask us to do, we can't (sometimes the requests are contradictory), but we are listening.
        If it's a personal comment, we'll listen to that too, but hopefully it won't influence us very much. (That was a joke.)
        If it's an ad for a product, esp from a competitor, we will read it, be influenced by it too. However none of these will be posted.
        You are of course free to post these items anywhere else you like.
        It's possible that moderation on this feed will help boot up an active widespread community of outliners publishing to the web. That's our hope! We're working on tools to make that easy and fun and powerful. It's certainly not unprecedented that lots of good can come from distributing the flow of ideas wide and far. That's what blogging is, after all.
        Other than these items, unless people come up with other ideas, everything else will go through.
      Feature changes in 0.74
        There's not very much new in the product itself.
        A few changes needed to be made to support moderation.
        And I still have more work to do on the back-end, so you can post items to the feed now, but they won't appear until the moderation feature is finished, server-side.
        Thanks for your help in this, it really has been and continues to be a great learning experience for us! :-)
May 2013
  May 31
    Fargo 0.72
      We did some work today on the community feed server.
      If you want to post to the feed, you need to reload Fargo.
      Be sure you're running 0.72.
  May 29
    Tech feature -- startup code
      In Fargo 0.71 there's a new Settings panel called Code, with a place to enter JavaScript that runs when Fargo starts up. Screen shot.
      Note of caution: If you're a programmer, be careful. If you're not a programmer, be much more careful. This is potentially a very powerful feature which means it is also potentially a very dangerous feature.
      Be sure you know what the code you're entering does, and that you trust the person who gave it to you. When in doubt, don't.
      With that caveat... we look forward to seeing what people do with this feature. ;-)
    Fargo 0.71
      Lots of little chotchkas in this release.
      Heart menu
        We use a lot of toolkits provided by some very generous developers and designers. The heart menu is where we thank them for their generosity. Screen shot.
        It's divided into three sections:
          1. Tools that we use in the workstation software, Fargo and Little Outliner,
          2. Tools that we use in our server software,
          3. Technologies we use everywhere.
      Suitcase icon
        There's a new icon in the left sidebar, the suitcase. Screen shot.
        When you click it, the Edit Attributes dialog opens.
        By popular demand, from the best users in the universe! :-)
      Save button hidden
        The Save button which was new in Fargo 0.65 would be visible even when viewing read-only outlines.
        Now it is only visible on outlines that you can edit.
      Fix in Set Name command
        If you try to set the name of a new outline that did not have a title, before we assign the name, we set the title to the name you chose.
        A few users set the name of the first outline they created in their first use of Fargo. When the outline got a title, we automatically change the name of the file from untitled.opml to title.opml. This would break their named outline.
  May 23
    Tech feature -- cssTextClass
      In 0.69, we added support for a new attribute, cssTextClass. If present, when we render the headline in Fargo, we add the class to the text. So this allows you to control the styling of text in Fargo on a per-headline basis.
      An example
        Using the CSS setting, I added this class:
          .greenText {
            color: green !important;
            }
        Then I set a cssTextClass attribute on a headline to greenText.
        As you might imagine, the text is now displayed in green when I view it in Fargo.
        BTW, it didn't work until I added the !important bit to the declaration. If at first you try a style and it doesn't seem to take, try adding this bit. I don't really understand what it does, but it seems to help. ;-)
      Why separate worknote?
        I'm trying out a new idea, writing up a technical feature in a separate worknote. I don't want all users to feel they need to understand this. We added the feature for more technical users, to give them a way to try some ideas out with Fargo.
    Fargo 0.70 -- Strikethrough
      There's a new strikethrough icon in the left margin. Screen shot.
      It marks the selected text with a strikethrough.
      If you're in structure mode when you click the icon, the whole headline is changed.
      Doing it again "unstrikes" the text (if that's a word).
    Fargo 0.69
      Phone-friendly
        Previous versions of Fargo did not work at all on phone-size screens. This version works a lot better. As with the tablet-size version of Fargo, we're going to iterate over this, so it will work better over time. If you have suggestions, please post comments here.
      Comments in WordPress blog posts
        You can now add comments to your blog posts, and they will not appear in the post on the WordPress server.
      Custom icons are now grayed
        Fargo now grays custom icons the same way it grays wedges.
        If an item is collapsed and has subs the icon is displayed in black.
        Otherwise it's gray.
      Fargo docs updated
        We added the big features from the Worknotes site to the Fargo docs.
  May 21
    Fargo 0.67
      You can now use the cursor keys in watched outlines in read-only mode.
    Fargo 0.66 -- Bookmarks
      Watched outlines
        A bit of terminology.
        There are two kinds of outlines in Fargo.
          1. Editable outlines.
          2. Watched outlines.
        Editable outlines live in the Fargo sub-folder of your Dropbox Apps folder. Open them with the File/Open command.
        Watched outlines live elsewhere. You can open them in read-only mode via the Open By URL command, also in the File menu. When they update, your view of them updates. Until now you had to keep the URLs of these outlines somewhere else, or leave the tabs open all the time.
      Bookmarks menu
        The Bookmarks menu is for watched outlines.
        It behaves more or less like the Bookmarks menu in a web browser. When you have opened an outline that you want to remember, choose Add Bookmark from the Bookmarks menu. A dialog appears asking what you want to call the bookmark. We suggest the title of the outline (or the long title if it has one).
        When you choose Edit Bookmarks, a new tab opens with the contents of the menu in an outline. You can edit the bookmarks there. The menu contains link nodes. You can change the text, or the URLs associated with the items, and reorganize the menu in any way you like.
        Only the top level headlines are included in the Bookmarks menu.
      Changes in the Icon Chooser
        The OK button changes to Close, to more accurately indicate what it does.
        We added a link to the wonderful Font Awesome github repo in the dialog.
        We open sourced our dialog, so other people may include the Icon Chooser in their apps. It's licensed under the GPL.
  May 20
    Fargo 0.65 -- Icon Chooser + Save Button
      Icon Chooser dialog
        There's a new Choose Icon command in the Outliner menu. It brings up a dialog with several tabs. In each tab are 35 awesome icons. Screen shot.
        Click on one of the icons to set the icon of the bar cursor headline.
        Click Close to dismiss the dialog without setting an icon.
      Save Button
        There's a new Save button in the right sidebar.
        It has two states:
          1. The outline in the active tab has changes. In this case the button says SAVE and is enabled.
          2. The outline has not been changed, then the button says SAVED and is disabled.
        This way you can see at a glance if your outline needs to be saved, whether or not you have AutoSave turned on.
        We hope, with this change, to prevent some data loss for users.
  May 17
    Fargo 0.64
      New commands
        There are two new commands in Fargo's Outliner menu.
          Add Include prompts for a URL and turns the bar cursor headline into an include node. The URL must point to an OPML file, though the command does not verify this.
          Add Feed turns the bar cursor headline into a node of type rss. A collection of these nodes forms a standard OPML subscription list. The URL should point to a feed, in RSS or Atom formats. Again, no attempt is made by Fargo to verify the format of the file being pointed to.
      Clipboard
        The internal clipboard now remembers outline attributes. So when you copy within an outline, or between two outlines in different tabs, the attributes are now preserved.
      Troubleshooting link
        Added a Troubleshooting link in the right sidebar and in the Docs menu.
  May 15
    Fargo 0.63 -- New icons
      This release adds 54 new icons from Font Awesome 3.1.1 to Fargo.
      Icons can be added to any headline by going to Outliner > Edit Attributes and adding a new attribute named "icon" with the value being the name of the icon you'd like to use. The name of the icon should be the name listed on the Font Awesome website without the "icon-" prefix. So if you wanted to use the new fire extinguisher icon you would just enter in "fire-extinguisher" as the name.
      Kyle
    Fargo 0.62 -- Open by URL
      One new command in this release, Open by URL, in the File menu in Fargo.
      It prompts for the address of an OPML file. The file opens in a new read-only tab. If the file changes, the tab display updates to reflect the change. It's like having a Reader tab inside Fargo. With this you can cook your own group of "Instant Outline" collaborators.
      You could, for example, watch the updates to the Small Picture users' directory, which is an OPML file, using this command.
      It's a deceptively small feature. It opens up a pretty large new set of applications for Fargo. :-)
      BTW, here's a great piece about Instant Outlining, written by Hutch Carpenter in 2009. That's what the Open by URL command enables. This has been an elusive goal for many years. We had I/O running at UserLand in 2001 when we were developing Radio. That's why we were able to get such an ambitious project done with a team that was spread out geographically. With Fargo, it seems we may have I/O in a package that can be used by a lot more people.
  May 14
    Fargo 0.61 -- Identity
      In this release we connect identity and outlines. This is someting we've been working towards from the day we started Small Picture. Actually quite a bit before that, if you've been following my writing on Scripting News.
      The idea is simple. Every outline can have a name. The name is much shorter and easier to remember than the URL assigned to it by Dropbox.
      For example: dave.smallpict.com. And when you want to view this outline in Fargo, you can leave off the domain and just ask it to open dave. When you do that you'll be viewing the public embodiment of me, the whole thing.
      This is the stuff I want to show you. The private stuff doesn't get named.
      You can think of it as the outline equivalent of a website. But it's bigger than a website, because it can contain websites. That's part of a future step we're going to take, which is already pretty far along (in its third generation, btw).
      Those are the high-level ideas. I'll be writing more about that on my blog. Now to the practical.
      Naming an outline
        You can name any outline anything you want, as long as:
          1. It hasn't already been named.
          2. The name you want to use is available.
          3. The name is 4 characters or more.
          4. It contains only alphabetic and numeric characters, or hyphens.
        To give an outline a name, click on its tab and choose Name outline in the File menu. A dialog appears. Screen shot.
        Enter a name. As you're typing, you're given an indication whether the name is available.
        When you're ready click OK. Be sure this is the name you want to use because it can't be changed or deleted.
      Be kind
        Right now there is no charge to create a name because these are early days, and you're helping us debug a new feature.
        So just name one or two outlines. If people abuse the feature, we'll delete the names and put a price on each.
      Making a name equal to you
        You can name any outline, but only one outline is you.
        To say which one that is, choose Settings from the system menu (upper-right corner of the window). In the first panel, named You, there's a new place to enter your Profile URL. Screen shot. This should be the address of your outline. If the name you chose is "mitch" then your profile URL is: http://mitch.smallpict.com/.
        Note: If you want to use another system for your profile you can point to that page from this spot. But other features may depend on it being hosted by us, or fully compatible with our implementation.
      Editing your profile
        You will notice that if you go to your profile page now, it's blank.
        If you edit your outline and add a top-level section called profile -- the contents of that page will display when you go there.
        Screen shot.
      Using the URL
        Your profile is automatically pointed to in the Community Feed when you post something new there.
        That way people who want to know who you are when reading something you wrote will be able to do that easily, by clicking on the eye icon that appears in the left margin when the highlight your name with the bar cursor.
        You can also include your outline within other outlines, or other people's outlines.
      Opening a named outline
        You may have noticed that the Community Feed is a special kind of outline in Fargo. When it's open in a tab it's called a "watched" outline. That means that whenever it updates the icon in front of its name changes to a lightning bolt, and when you click on it, you'll see the changed text.
        Named outlines work the same way. If you choose Open By Name in the file menu, and enter the name of someone else's outline, you will be able to watch changes in that outline. This works extremely well if you're collaborating with other people and want to keep up to date. We call this Instant Outlining.
  May 10
    Fargo 0.60 -- Long titles
      There are places where you need a long title for an outline, and places where you need a short one. A short title is good for a tab. But in the Reader app, you want a longer more descriptive title. This really showed up when we were viewing the Community Feed in Reader. The title at the top of the page said "Feed." That looked like a bug to me, even though the software was fully functional.
      So, primarily to make Reader work better, we changed the Set Title command in the File menu. It now gives you a way of setting two titles, one short and one long. You can set a description for the outline.
      Here's a screen shot of the new dialog.
      There's a new version of Reader to go with these changes, version 0.11.
      Here's an example , Reader displaying the Community Feed, which now has a long title and a description.
  May 8
    Fargo 0.59 -- Community Feed
      The Community Feed is an outline that any user of Fargo can post to when there's an idea they want to share with people who are listening.
      Who is listening? What does it mean? How will we use it?
      These are, at this time, unknowns. :-)
      Posting to the feed
        When you have an item you want to share with the community, put the cursor on it, and click in the new Feed icon in the icon chain.
        A confirmation dialog appears, making sure you want to add the item to the community feed.
        When it's done, you'll hear a beep sound.
      Editing an item
        If you edit your item and want to update it in the feed, put the cursor on the top headline and click the Feed icon again. It automatically updates the Community Feed with your changes. No confirmation this time. When it's done, it beeps.
      Watching the feed
        There's a new command in the Docs menu, probably just a temporary home, called Community Feed.
        When you choose it a new tab opens displaying the contents of the Community Feed.
        When it updates its icon will change to a lightning bolt. When you select the tab, the icon changes to what it was before. That's how you can tell that it updated.
      Video demo
        Here's the video on YouTube.
        http://youtu.be/g85e5lB6pqw
      Where's the feed?
        It's just an OPML file, of course.
        http://smallpicture.com/feed.opml
  May 6
    Fargo 0.58
      Chris Wolverton wrote a blog post today listing some things we want to fix in Fargo. The one that was bugging me was the inconsistent implementation of Return in our dialogs. In some places it dismissed the dialog, but in most dialogs, it did nothing. I fixed most if not all of the dialogs in Fargo, they all handle Return properly. If I missed any please post a comment here, with steps to reproduce.
      Dave
  May 4
    Fargo 0.57
      There's a new checkbox setting for WordPress blog posts, that allows you to pass the text of each post through Markdown before it's sent to WordPress.
      Screen shot.
  May 3
    Fargo 0.55, 0.56 -- Markdown
      Fargo now has a built-in Markdown processor.
      We're using the open source Pagedown library.
      The Fargo docs have been updated to include a new section on Markdown.
      Here's an example of an outline, and the Markdown-rendered version of the outline.
      We generate the text from the outline and pass it through Pagedown, and save what it returns to the #markdown sub-folder of the Fargo folder.
      Two returns for every headline (0.56)
        Based on feedback from Jason Gilman, I changed the way we generate text before passing it to Markdown. Previously we added a single newline character at the end of each line. Now we generate two carriage return characters. That way each headline generates a new paragraph in Markdown.
        This kind of feedback, especially early in the process, is very important. We can change things now because there is no installed base of documents that use Markdown. Later it will be harder to make a change because of potential breakage.
        This was the only change in 0.56.
      Consider it experimental
        We've tested the processor and it seems to work, but neither Kyle or myself are experts on Markdown.
        Markdown support was a much listed feature request, so we know that there are plenty of Fargo users who will know what to do with this. However the conventions on how to use outline structure are not at well-understood. It's all very new as far as we know.
        If there are problems, please report them in a comment here. Also if you feel we should be generating the text differently, post a comment. It's just the beginning of outliners and Markdown, so we may have to make changes in how this works.
        We're also planning on implementing Markdown in Trex, the server-side CMS we're building to work with Fargo.
  May 1
    Fargo 0.54 -- WordPress
      Fargo-WordPress connection ships.
      You can create new posts, edit them, organize collections of posts in the outliner, and use the outliner to author WordPress blog posts.
      A new section of Fargo Docs that walks you through the setup and creating and editing a post.
      Screen shot of the Blog settings panel.
      A homemade video demo showing how to write WordPress blog posts with the new version of Fargo.
      An OPML file with the most recent 100 new posts. The same data in a web page.
      Dave
    Fargo 0.53
      Control over how often autosave happens
        It's possible if you're typing for a long time to cause more updates more frequently than Dropbox allows.
        There is a workaround -- if you pause for a minute without typing, the condition clears.
        We added a new pair of settings, in the Auto-save panel, that gives you control over how frequently Fargo saves.
        1. A new checkbox allows you to turn off auto-save. If it's off you must remember to save using the Save command in the File menu.
        2. A new setting determines the minimum number of seconds between saves. If you're saving too often for Dropbox, try increasing this number to 15 or 20. That should cut down the number of saves. No matter how often you pause it will never save more often than this number of seconds.
        Screen shot.
      New Docs menu
        The iPad version doesn't have the right sidebar, so there were no links to docs for users.
        I also added links to the Worknotes site, the mail list, and a page showing all the Font-awesome icons.
      Eye icon fix
        When you save a WordPress post the first time, the eye icon wouldn't display. Now it does.
        Note: the WordPress feature is in testing. We expect to release it publicly in 0.54 or 0.55.
      Fixed cribsheet
        There was a change at the top level of Fargo that set the margin-top of .bs-docs-grid .row-fluid to 50px.
        This added a 50px margin to the cribsheet too.
        I fixed it so that the change only applied to the top level grid, and the cribsheet looks good again.
        Also verified that the tablet version works as well.
April 2013
  April 25
    Fargo 0.52 -- Tablet UI
      We've known, since starting work on Fargo last year, that the outliner had to work great on all devices. When we hooked it up to Dropbox the need became even more apparent. The same outlines that we work on on our Macs and PCs had to work well on iPads and Androids.
      A bit at a time
        So this is how we're approaching it. A little bit at a time. We solve a few problems, make it work a little better, come back later, and make it work a better. Eventually we figure it out.
        The reason this is the best approach is that while we had excellent prior art for desktop outliners dating back almost 30 years, there isn't any good prior art for mobile device outliners. So we want to go slowly so we make better design choices.
        Today, with Fargo 0.52, we're shipping the first iteration of mobile support. In this release we smooth out the interface on tablets. Following is a list of changes.
      General note
        The changes below only apply when Fargo is running on a tablet device.
        The functionality in other environments is unchanged.
      Double-clicking
        When you double-click, the event was intercepted by the system, and it would cause the text to zoom in.
        Now, when you double-click, it expands the headline the bar cursor is pointing to.
      Landscape and portrait
        When you switch from landscape to portrait or the other way around, Fargo correctly adjusts the outline display.
      Tapping wedges
        Tapping on headline wedges has been made easier. The tappable area is larger for the iPad.
      Single-tap on a wedge
        You can tap once on a wedge to expand, tap again to collapse.
      Reorganizing
        Use the Outliner menu to reorg the outline. No change.
        Dave
  April 23
    Fargo 0.51
      We've gotten a lot of feedback on the initial user experience for Fargo, and decided to take another look.
      The result is a new intro dialog.
      This is what the previous dialog used to look like.
      I wrote a blog post about this feature.
      Dave
    Fargo 0.50
      Navbar
        The Fargo navbar is now fixed when vertically scrolling.
        Kyle
  April 22
    Fargo 0.49
      Icon chain
        The icon chain to the left of the outliner is now fixed when vertically scrolling.
      Tabs
        If there is an error loading an outline into a tab an error box will now display at the top of the outline describing the problem and offer the option to try again or close the tab.
        If you ever run into a situation where no tabs are present, navigate to the #prefs folder within the Fargo folder on Dropbox and remove the file tabs.json.
      International characters
        When we save files to Dropbox, Dropbox attempts to detect the encoding (ASCII, Latin1, UTF-8) of the file. Sometimes their encoding detection is incorrect. This caused international characters to occasionally be encoded incorrectly when reading an outline back into Fargo.
        This release has a change in it to avoid that encoding problem. Files are now read from Dropbox in a (binary) way that prevents the auto-detected encoding from being applied. International characters should no longer be encoded incorrectly.
        Kyle
    Fargo 0.48 -- View in Reader
      The big change in 0.48 is the introduction of Small Picture Reader.
      It's a separate app, in a web page, as with all our apps, that is used to read outlines, the same way Readability is used to read web pages.
      To use it
        1. Prepare an outline in Fargo that you want to share.
        2. When you're ready, choose View in Reader in the File menu.
        3. Reader should open, with your outline displayed.
        4. You can then send the URL of that page to friends or colleagues, or use the Tweet icon in the left margin to send it to your Twitter followers.
      Tips for readers
        Reader is always checking to see if your outline has updated, and when it does, it automatically displays the updated outline. This can be disturbing if you're reading an outline, you can lose your place.
        If this bothers you, click the lock icon in the left margin. Reader will hold on to any updates, and only show them when you unlock it. When there are changes the lock icon will change from gray to green.
      Demo
        Here's an example of an outline from Fargo being viewed in Reader.
  April 19
    Fargo 0.47
      Restoring tab state
        There was an issue with refreshing Fargo when the last active tab was renamed or removed from the Dropbox folder.
      Dropbox error reporting
        An error box will show above an outline if there are any issues with saving an outline to Dropbox.
        Dropbox error box screenshot.
        Kyle
    Tip: Reload often
      A general note...
      We have heard reports of people losing work in Fargo.
      We're looking into them, and working on fixes, and will report when we have them.
      In the meantime -- at least some of the problems can be worked around by reloading Fargo.
      Tips
        1. Reload at least once a day to be sure your connection with Dropbox is active.
        2. If you make changes to the Fargo folder, reload Fargo after making the change.
        3. You can back up all your work by making a copy of the Fargo folder.
        More coming soon.
        Dave
    Redirect
  April 18
    Fargo 0.46
      For this release be sure to hold down the Shift key and hit the Refresh button to be sure you have the latest version.
      Untitled document
        Changing the title of an Untitled document will save a new OPML file based on the new title and remove the untitled.opml file.
      Charset encoding
        If a file is read from Dropbox and the character set specified within the Content-Type header is ISO-8859-1 the contents of the file will be decoded from UTF-8 to avoid character encoding problems.
  April 15
    Fargo 0.34
      On Windows instead of the "Cmd" symbol for menu items, it should now say Ctrl+.
      The Preferences command moves to the System menu, and its name changed to Settings.
  April 11
    Fargo 0.14
      Workflowy is a browser-based outliner that a number of Little Outliner users like, and naturally they want to move ideas into and out of both products. It would be easier if they supported OPML import and export, like our outliners do, but they don't at this time.
      So we added a feature in the Small Picture outliner that handles Workflowy's export format. So you should be able to paste outlines that you export from Workflowy into Fargo and (later today) Little Outliner.
      Howto
        1. In Workflowy, get the section of the outline that you want to export on screen.
        2. Hover with the mouse just to the left of the main headline and nudge the mouse down to reveal the full menu, and click on the Export command. (Screen shot.)
        3. A dialog appears containing the exported text. Be sure to click on the Plain text option. (Screen shot.)
        4. Copy all the text, then go to Fargo (or Little Outliner, later today). Position the cursor where you want to paste the text, and Paste. (Screen shot.)
    Fargo 0.12
      The main visible change in 0.12 is the display of attribute values in the right sidebar.
      How to turn this on:
        1. Choose Preferences from the File menu.
        2. Click on the Advanced tab.
        3. Check the box to display attributes in the right sidebar. (Screen shot.)
        4. Click OK.
      Now as you move the cursor through the outline, you will see the attributes of any headline that has them.
      Note: Since every headline has a "created" attribute, we don't display it. And any attribute that's longer than 10 characters is truncated to 10 (just for display of course). URLs can be very long, and there's limited space in the right sidebar.
      If you want an outline to look at that has headlines with lots of attributes, here's my Movies subscription list. Download it, and copy it into your smallPicture sub-folder on Dropbox and open it in Fargo.
  April 2
    Little Outliner 0.40
      First-time, in text mode
        When the outliner boots up for the first time, for the first-time user, it is in text mode not structure mode.
        That means that insead of showing the bar cursor, we show a blinking caret cursor.
        This is more accurate. It's the first thing a first-time user should do. The software should invite the user to type. That's what the blinking caret says.
      Moved the clock
        In the right sidebar, the clock moves below the version number. Looks a little more balanced, imho.
March 2013
  March 31
    Plug-in Demo
      In Little Outliner 0.39 we will start to explore the idea of web-based outliner plug-ins. Right now, it's just a demo, an illustration of how the idea may work when developers can add functionality to the outliner through web services.
      How to demo
        1. To enable the demo, choose Preferences from the Outliner menu, and click on the Demo tab.
        2. You'll see a checkbox that enables the plug-in demo. Check it and click submit.
        3. Choose Import OPML from the Outliner menu. Enter this URL into the dialog.
        https://dl.dropbox.com/u/36518280/outlines/hazelnut.opml
        4. Now place the cursor on the top-level headline, My presentation, and click the new icon (screen shot).
        5. In a few seconds a preview of a presentation should appear. Step through it by clicking on the arrows in the lower right corner of the window.
      Editing
        You can edit my slides or create your own.
        The top level headline is the title of the show. Its subheads are the titles of slides. And the text under each slide are the bullet points.
      Publishing
        You can create a finished presentation that you can send to others by clicking the Publish button in the lower left corner of the Preview dialog.
        Note that since this is just a demo, all published presentations will be automatically deleted one month after they are published. So if you want to keep a copy you should download it before the month is over.
      The idea
        This part is for developers.
        When the user clicks the icon, a dialog opens, and calls a web service. It returns HTML code that is displayed in the dialog.
        There is a single parameter to the service, the OPML text of the outline pointed to by the bar cursor.
        The plug-in then processes the OPML in some way, and returns HTML which is then displayed in the preview dialog.
        The HTML text could simply be a message saying that the process worked. Or it could be, as in the case of our demo, a rendering of the outline.
      Why this is useful
        Outliners are a good way to compose content for rendering.
      Is this open?
        Yes. OPML is a simple format that anyone can process. Nothing hidden there.
        And the idea of an AJAX web service also is very open. We use jQuery to make the call. As long as you can receive a call from jQuery you should be fine.
        The presentations are displayed by reveal.js.
      This is just a demo
        Right now we don't have a way for users to add items to the plug-in list, that's why it's just a demo. But it's not very far from being a for-real feature. :-)
      Update
        Here's a blog post about plug-ins.
  March 28
    Little Outliner 0.38
      Fixed issues in the cribsheet.
      Keystrokes no longer flow through to the outline while the cribsheet is displayed.
      Any keystroke causes the cribsheet to be closed.
  March 27
    Little Outliner 0.37
      New cribsheet shows keyboard commands, and important mouse gestures.
      Not meant to replace the Outliner Howto, so please do read that. Use it when you quickly need to remember a keystroke.
      To access the cribsheet, either press Cmd-? or click the Cribsheet link in the right margin.
      Screen shot.
    Little Outliner 0.35
      Fixed a problem that caused the title not to display when Little Outliner starts.
      Download OPML
        New experimental command.
        It should work in all browsers, except IE9 and IE10.
        Thanks to Dan MacTough for this excellent hack.
      Don't save if it's been one or more seconds since the last keystroke
        The user has to let up a little before we save.
        Saw a comment from Alec Perkins saying that he had problems if he saved on every keystroke. We're basically doing that now. Better to be a little more conservative.
      Smaller font in the Outliner menu
        And a little less space between the commands.
        Trying to make a little more room for people with shorter screens.
  March 26
    Little Outliner 0.34
      Fix problem with URL params encoded like this. The JavaScript built-in function doesn't deal with them correctly.
      Add a link on the home page to the local storage FAQ that I wrote this morning.
    Little Outliner 0.33
      Fixed bugs in "reader" mode.
      http://littleoutliner.com/?reader=http://smallpicture.com/states.opml
      The title should be the title of the outline you're viewing.
      Editing commands in the menu are not present. The preferences command is still there, but the prefs that would impact the outline being displayed don't do anything.
  March 25
    Little Outliner 0.32
      Yes, it was lame to ship a product with Mac cmd-key labels on Windows and other operating systems.
      That should be fixed now. On Windows, cmd-keys are prefixed with Ctrl+.
      I'm assuming it's the same on Linux?
    Little Outliner 0.31
      New "Title" prefs panel. Allows you to set the title and say whether or not you want the title to display above the outline.
      The Set Title menu command was removed.
      When the bar cursor points to a headline with an xmlUrl attribute, allow the user to double-click to open the feed in another browser tab.