Fargo Blog

2015
  February 2015
    February 15
      Fargo 1.69
        In this release, a way of connecting from a "Fargo" outline to "myword.io".
        I don't want to commit to a user interface for this at this point, so you have to be familiar with adding scripts to Fargo's menubar to make this work.
        #### Editing the menubar
        1. To add a command to the menubar, follow these instructions.
        3. The command should just call this JS function: viewInMyword ()
        2. Post questions on the Fargo2 mail list, or in a comment here.
        #### How to use
        1. Create a blog post in Fargo as you normally would.
        2. Put the cursor on the main head.
        3. Choose the command you added above.
        4. Click on OK to view it in myword.io.
        5. myword.io should come to the front, displaying your post.
        #### Example
        Here's an example of a myword.io rendering of a Scripting News post.
        #### Embellishments
        1. Add an img attribute on main headline to replace the Beatles image.
        2. Add a description att on the main headline, to add a description.
        3. If you aren't using Markdown, add an att named flMarkdown set false.
2014
  October 2014
    October 12
      Rolling on the river
        This feature will be of interest to people who have "River.js" files. This is the output format of "River4" and previous river-of-news aggregators.
        In Fargo 1.68 there's a new <includeRiver%> macro. It takes one parameter, the http address of a River.js file.
        <%includeRiver ("http://rss.scripting.com/rivers/iowa.js")%>
        #### Testing it out
        You can use my personal river. The NYT river is also useful for testing.
        I included my personal river on today's Scripting News home page, with hilarious results. Not saying this is particularly useful, but it's really nice when two big pieces of technology "just work", in this case, they worked the first time I tried it. Hala.
        #### Tina Turner would like to sing you a song
  September 2014
    September 9
      Fargo and OPML, Evernote, Radio3
        On Twitter, Frank Meeuwsen asks a good question about Fargo.
        "Would it be possible to update a Fargo Outline from within Dropbox? So add/update directly in a folder instead of the editor?"
        #### Yes
        I answered, yes no problem with that. OPML is a text-based format. Just edit the text in whatever you want, and save it to the folder.
        The best way to learn about OPML is to create something in "Fargo", save it, and then drag the file onto a plain text editor and see what it generated. Fargo doesn't care how the text gets there. So you just have to produce what it's expecting. I tried to design the elements so if you think about it, you'll figure out what it's doing. And I'm happy to answer any questions people have, to the extent that I can.
        #### Connecting with Evernote
        What's interesting is that Frank is an Evernote business consultant, and Evernote is a service that Fargo and our other products should hook up to. Imagine "Radio3" able to post to Evernote alongside Facebook, Twitter, WordPress and RSS. That's the philosophy of these products. Let's make users' data flow smoothly. There's a lot of untapped potential here.
  August 2014
    August 20
      Fargo outage cleared
        We had an outage starting at approximately 2AM Eastern this morning that just cleared, at 1PM.
        There was a problem with the Dropbox API. It was saying every call Fargo was an error.
        I posted a status report on the outage almost immediately before it cleared.
        Glad to have "Fargo" back! ;-)
    August 6
      Interim fix
        No version number change for this fix.
        "Fargo" would fail on startup if you left the cursor on the first line in the outline.
        Fixed.
    August 5
      Fargo 1.66
        #### The simplest of features
        "Fargo" now remembers the bar cursor location when it saves an outline. It automatically restores the cursor when the outline is reopened.
        #### Technical details
        There's a new <head> element in the OPML that Fargo produces, <lastCursor>.
        Its value is a number, the number of times you have to move the cursor flatdown from the summit, after the previously expanded elements are expanded.
        #### Other outliner-based apps
        "Little Outliner", "Happy Friends" and "Thesaurus Land" also have this feature. ;-)
    August 1
      Fargo 1.65
        Updated "Fargo" to use Font Awesome 4.1 with 71 new icons.
        Thankfully, the Font Awesome updates go pretty easily these days.
        You can use the new icons with the icon macro.
        Example: <%icon ("bomb")%> produces a <%icon ("bomb")%> icon (obviously).
  July 2014
    July 12
      Fargo 1.64
        An alternative to Markdown in outlines
          I missed having expanding outlines, and I want to use the structure in interesting ways in RSS, so I decided to add a small feature to Fargo, that lets us edit outlines as they will be presented, with structure.
          This blog post is an example of such an outline. As is the one you're reading now. ;-)
          At the outset of the Fargo 2 process, I wanted to force myself to use Markdown, assuming if I had to make it work with outlines, I'd figure out how to combine the two. 1/2 year later, and it hasn't happened yet. And I want to make outlines that have real structure, not use Markdown's visual indication of structure without structure.
        How to
          To give it a try, create a headline of type outline with the big + icon in the left margin.
          In the Attribute editor (click on the Suitcase icon in the left margin) add an attribute called flMarkdown, with the value false. When you're done the atts should look like this screen shot.
          Then add some outline material under the headline. It's important to indent a few times and add structure, or else it'll look exactly like the Markdown-style posts.
          When you click the Eye icon to view it, it should have wedges that you can click to expand and collapse the outline structure.
        Attributes
          There are a few attributes you can use to control the way outlines are rendered. They're explained below.
          leftIndent attribute
            If you put a leftIndent attribute, a number, on a headline, all its subs, and their subs will be indented by that number of pixels. The default is 0.
          collapse attribute
            If you put a collapse attribute on a headline, its subs are initially collapsed. This lets you control the presentation.
          img attribute
            A URL, points to an image, which is added to the headline, floating to the right.
          url attribute
            If present it's where you go when the image is clicked on, if there is an img attribute.
        Outlines in RSS items
          Each item now has an outline element that contains most of the structure and attributes of the outline.
          We don't include comments.
          We don't include two attributes: isFeedItem (they are all true, because it's in a feed) and isComment (again, all true, because comments are not included).
          The outlines are in the new source namespace. What you'll see in the feed is <source:outline>.
        RSS fixes
          In 1.63 we added macro and glossary processing to the RSS feed builder, but the processing was done in the wrong place. The result is that unencoded XML could end up in description and title elements. This is not legal XML. In 1.64 we do it selectively, before encoding, only in title and description elements.
          We also evaluate Emoji codes in the feed.
        Fix relating to tweets
          When we introduced the tweet type it broke the eye icon. If a document contained a tweet, it sent you to a non-existent page when you click the eye.
    July 7
      Fargo 1.63
        While I'm waiting for Facebook to approve the new version of "little card editor" I thought I'd do a little diversion to solve what has been a thorny problem in Fargo that has prevented a lot of interesting things from happening.
        The feed has no pagetable
          When you're rendering the RSS feed for a site, there is no context for the rendering. This means that none of the preferences for the site are available to the RSS building process. And it means there's no way to use attributes to configure the RSS building process. This has held back a bunch of interesting development.
        Idea
          So how about this. The pagetable for the RSS building process is built from the global settings, plus the user's cmsPrefs.opml file (if there is one) plus the top level of the site whose feed it is. That gives us three levels of attributes, one that applies to all Fargo sites, one that applies to all the user's Fargo sites, and for the site that the RSS is from. Let's give it a try and see if it works.
        Testing
          Okay the feature is in. Now let's see how it works. :-)
          Here are some glossary items from my cmsPrefs.opml: "Happy Friends", "Emoji", "Little Card Editor".
          Here are some glossary items from the global file: "cheesecake" :-) :-(
          And one from the Fargo blog outline: "cmsPrefs.opml"
          If the new feature worked, when we look in the RSS file, they should all be evaluated.
          One more thing, let's check a pagetable macro: <%opmlOwnerName%>.
          Here's what this text looked like in Fargo.
          And here's what it looks like in the feed.
  June 2014
    June 27
      Fargo 1.62
        There's one major feature in this release, the ability to render tweets.
        A tweet is a headline whose type is tweet. They can appear in any kind of page, of any type.
        They will be rendered correctly in pages of the following types: outline, html, stream, presentation, markdown, bloghome.
        This is the Fargo side of the connection with "Happy Friends".
        There is a blog post on the Happy Friends site that explains the hookup from that side. ;-)
        #### How to use a Happy Friends outline in Fargo
        Basically...
        1. Get the outline from Happy Friends.
        2. Choose Open by URL in the File menu. Enter the outline from step 1.
        3. That gets you an outline with tweets in Fargo.
        4. Copy and paste those into your outlines in Fargo, and render as normal.
        The tweets should show up in your pages as they do in mine. ;-)
        For a more detailed narrative, with an example, see this post on yesterday's Scripting News.
    June 5
      Fargo 1.61 :beetle:
        Fixed a problem where the CMS would think it was seeing emojis in the part of the stream template responsible for phone and tablet-size screens.
        Thanks to Jason Cobb for spotting the problem.
        You should rebuild any pages that rely on the stream template.
        Be sure to reload the "Fargo" app before doing so. :cop:
    June 4
      Fargo 1.60 :kiss:
        A new release of Fargo today with one small feature, Emojis.
        A good friend showed them to me, a few weeks ago on a trip to San Francisco. I was immediately won over. Charmed by them. It's a new fun language.
        Colorful and cute and somewhat irreverent.
        #### Syntax
        The best part is that there's a syntax for Emojis in text-based apps like Fargo.
        For example, :baseball: gets you the Emoji for :baseball:
        There's a list of all the codes on the Emoji Cheat Sheet.
        As you can see this syntax is already supported by lots of famous apps including Campfire and GitHub. Add "Fargo" to the list.
        #### Turning it off and on
        The new Emoji feature is on by default, you can turn it off with a # attribute:
        #flEmojify "false"
        #### Thanks to
        We're using the Emojify toolkit. It went in real easy. Thank you.
        #flPgfPermaLinks "false"
  May 2014
    May 20
      Commands to turn images on and off
        I have commands in the Links menu on Scripting News that turn images on and off.
        You may want to add these commands to the menu of your website, so users can have the option to have images on. It's also useful for debugging.
        Here's an OPML file with the two commands. Open the file in Fargo, copy the commands and paste them into the menu you want to add them to.
      Fargo 1.59
        #### Stream 2
        With this release there's a second version of the stream template, and the CMS generates a slightly different structure for streams. The JavaScript code in the stream template has been changed accordingly.
        #### A quieter stream
        I did an experiment over the weekend, adding a command to Scripting News that turned off background images. I tried it, and immediately wanted to keep them off. The text is much easier to read. And that matters a lot. I wanted to get some experience with images in the background, and I did get that experience. It'll show up again in another context. And you can still have the images now, if you want them. So that's good. Nothing went away, the defaults changed.
        #### Demo
        "Scripting News" is the demo.
        #### If you want the old version
        Add #streamVersion "1" in your cmsPrefs.opml file. You should get the same behavior as before v1.59.
        If you want the new version, you shouldn't have to do a thing.
        #### A list of changes
        Here's a list of technical changes that were made. If you don't care you can skip this part.
        We don't generate the .divStreamTopSpacer element.
        Copied fonts into fargo.io/code. Faster loading, not relying on Google servers, avoid possible breakage issue.
        Section heads are bold, Ubuntu.
        Increase density of foreground text. It's opacity goes from .9 to .98. Also background color changes from white to whitesmoke. Border color goes a little darker to gainsboro.
        divStreamDay needs styles for background image
          added these styles:
            -webkit-background-size: cover;
            -moz-background-size: cover;
            -o-background-size: cover;
            background-size: cover;
            background-position: center;
            background-repeat: no-repeat;
        divStreamDayImage goes away
          in first version, if there was a backgroundImage att on the day, we'd generate a divStreamDayImage element with the background image as its background.
          in the new version, we don't do this. the backgroundImage data is on the day div, and we can add the image at render-time
    May 15
      Fargo 1.58
        #### One small fix in this release
        There's just one very small change in this release, that may fix a problem people are having with dates in noteblog-style blogs. I don't have a set of steps to create the problem on my system, that's why I'm not sure if this is the fix or not, but I did find a problem.
        #### Use the big gray plus icon to create posts
        One thing that was clear from reviewing the CMS code, you won't get good results with stream types if you make the calendar entries by hand.
        You should use the big gray plus icon at the top of the icon bar at the left of the window to create new blog entries. It automatically sets the attributes up the way the CMS is expecting them.
        If you don't use the plus to create blog entries, you may see problems with dates. This may have been responsible for some of the problems we've been seeing.
    May 13
      Little Outliner 1.40
        The last release of "Little Outliner" was in April 2013. After so much time, it had become dated, in need of a refresh. That's the point of this release, version 1.40.
        #### What?
        Here's a brief explanation for newbies. :-)
        #### Changes
        1. The Outliner menu above the outline display has been replaced with the menubar we use in "Fargo".
        2. In addition to the Outliner menu, there's now a Reorg menu and a Docs menu.
        3. The Arrow Pad from Fargo has been added. The command to activate it is in the Reorg menu.
        4. The clock was removed.
        5. The explanatory text at the bottom of the page was removed, and replaced with a What is this? link that takes you to a full page description of Little Outliner.
        6. The copyright notice was updated.
        #### Archives
        Here's a screen shot of the previous version, and the updated screen shot.
        The previous version of Little Outliner has been archived here.
        The last build of Little Outliner before this release was on 4/16/13 at 1:56:03 PM.
    May 12
      Fargo on NPR
        Yes, Fargo was on NPR this morning, in a story about a new site called Glass that's edited, and presented, as a Fargo outline.
        I've linked to the new site and the NPR report on today's Scripting News.
        It's very exciting. Lots of new users today, and I'm hearing from all kinds of old friends who didn't know about Fargo.
        The people at Quartz who are doing this site are incredible, innovators, brilliant, and hard-working. We had a lot of fun with this project but I didn't really have to do anything but answer questions, Fargo really works.
    May 11
      Setting page title on deep links
        When you click on one of the # links on a stream page, it takes you to that section of the archive page for the day, with the item whose # you clicked on highlighted.
        Now it also sets the title of the page with the text of the item.
        So if you click on today's News startups nothing special, if you look at the title of the page, it should read Scripting News: [News startups nothing special].
        If you use a linkblogging tool to point to this, it will automatically be populated with the correct text for pointing to the article. We even add the square brackets so it will be correctly linked if the linkblogging tool is Fargo. ;-)
        I love to sharpen the edges products to this level of detail. It takes time to figure out where they need adjusting, but we've already been using the stream type for a couple of months.
      Setting frame color on stream types
        Sometimes when I use a background image on "Scripting News", I want the frame of the text to pick up a color element of the image. I just wanted to set the color of the frame.
        This could be done with a custom #style directive, but this comes up so often, I wanted a shortcut for it, so I added one. ;-)
        Now you can set #streamTextFrameColor to the color you want to use.
        I do it in today's Scripting News, if you want an example. The color is set to gold.
        I also took this opportunity to update the GitHub repository for Fargo templates.
    May 10
      Cameron Hocking on Fargo in Education
        It's great to see people starting to use Fargo in education! :-)
        http://hocking.smallpict.com/2014/05/10/fargoInEducation.html
        Dave
    May 8
      General bug reporting note
        If you think Fargo isn't behaving correctly, it's often a good idea to try reloading the app.
        When reporting a problem, be sure to tell people what version you're using. It's possible the problem was fixed in a release that you haven't installed yet.
        To install a new version of the app, just reload "fargo".
    May 4
      I did some work on my noteblog
        #### Yellow was too bright
        A few notes about scripting.com.
        I thought yellow was too bright a color for highlights, so I changed it to gold, by adding this directive at the top level of my site outline:
        You can use any of the pre-defined web colors, or any value that can be used as a color in a web page.
        #### Bold-face sub-heads
        I wanted the headlines with subs to be bold and in a nice serif font. So I added a #style directive.
        You can see how I made these changes by opening the outline I use to edit the noteblog.
        #### My feed changed
        I changed the main feed for scripting.com to the one of my noteblog. This means that people who subscribe to my site in a feed reader will now get title-less items and titled items.
        This is good news for other people who use "Fargo", because any site that handles my feed well, will also do well with yours. It also means other blogging tools can allow users to enter title-less items, which is good if you think Twitter could use a little competition, as I do. I think this will be important for news organizations as well. :-)
  April 2014
    April 29
      Fargo 1.57
        #### Render icon goes away
        A couple of minor changes in this release.
        A new icon was introduced in the first beta of Fargo 2, but it was never completely implemented, and in practice isn't very useful. The space will be better used, and space in the left margin is limited.
        #### Date bug in stream style sites
        There was a bug in the stream sites, reported by Lloyd Davis, where the date displayed on a day's post would be incorrect. There was a call to the date formatter in the CMS that didn't include information about the user's timezone. I checked all the other calls and they appear to be correct.
    April 23
      Fargo Publisher 0.95
        New in this release is the ability to write your own request handlers in JavaScript.
        I added this feature because I wanted to try writing my own handlers without having to update Fargo Publisher.
        #### How it works
        If a request comes in that doesn't match any of the built-in functions, we check the scripts sub-folder of the data folder. If an item matches, we eval it and return the result.
        How matching works: If the request is for /xyz then we look for xyz.js.
        We convert the request to lowercase, so that requests are case-insensitive, however the files in the folder must have all lowercase names.
        #### Error handling
        If we don't find it, we return 404. If there's a script error we return a 503.
        #### Example
        If the script is in count.js and the server is running at pub.fargo.io, you'd access it through this URL: http://pub.fargo.io/count. You can try it, click the link. Reload the page. Every time you load it, the count should increment.
        globals is a global object that you can hang persistent values on. They persist for the life of the server, when it's rebooted it's reset. You can think of it as a scratchpad.
        #### Read the source
        Here's the source for the server. To find the part that implements this, search for 404. We look in the scripts folder before calling it a Not Found error.
        #### Blog post
        I wrote a bit about this on Scripting News.
    April 20
      Fargo 1.56
        Some people want to edit more than one WordPress blog with Fargo. To make that possible, Fargo now has an outline-level setting for the URL of the associated WordPress blog.
        To change the setting, choose Outline Settings from the File menu. Click on the Overrides tab. Enter a new value for the WordPress blog URL.
        Here's a screen shot showing an outline with a different WordPress blog URL.
        When you save a post from the outline, if this option is set, the post will be saved to the indicated WordPress site.
        Note: There's no ability to override the username or password. This information has to be stored in the OPML file, and it's not cool to store passwords in such an easy-to-share format.
    April 18
      Fargo 1.55
        Fixed a bug where an old version of the Settings dialog in the System menu would appear.
        This was caused by an error in mapping domains. It's a long story, but it's fixed now. However, it suggests there may be other similar problems in Fargo that we should be watching out for.
        If you see any dialogs or user interface elements that appear to be dated, please report them here or on the Fargo2 list.
    April 17
      Fargo 1.54
        There's one new feature in this release, the ability to download an entire WordPress site into a Fargo outline.
        #### Caveats
        1. There's no user interface for the feature.
        2. There are limits to what it can do.
        3. I don't know how well it will perform on WordPress sites other than the ones I tested with.
        #### How to
        1. Make sure that you've configured Fargo to talk to the WordPress site you want to use, in the Blog panel of the Settings dialog in the System menu, at the right edge of the menu bar (the menu under your Dropbox name).
        2. In any outline, type this: getMyWordPressOpml () on a line by itself. Press Cmd-/ to run it.
        3. After a while you'll see a dialog that says that it has downloaded your site into the wordpress folder. This is a sub-folder of your Fargo folder. Screen shot.
        4. In the file system, move or copy the file into your Fargo folder.
        5. Choose Open in the File menu.
        6. Choose the outline you just moved. With any luck the outline will open.
        #### What you can do with this outline
        If you want to make an editing change to any of the posts, do it as you would with any WordPress post you created in Fargo. 1. Make the change. 2. Put the cursor on the title headline. 3. Click the WordPress icon in the left margin. 4. Wait for confirmation. The Eye icon should take you to the changed version of the post.
        Deleting or moving the posts has no effect on the website. You can organize the posts any way you like.
        The great thing about this feature is that you can easily edit the contents of an entire blog using the outline interface to find your posts. You have the full organizational power of the outline to arrange your blog to make editing as easy as you want it.
        #### What's next
        I want to release the source code for the server, where all the work in conversion is done. The ability to export an entire WordPress blog in a single file is a new thing for WordPress, as far as I know. It's something I want to share widely, because everyone needs this ability, and I don't want to host the service for everyone in the world. :-)
        The server is written in JavaScript and runs in node.js.
        Update: The server software has been released.
        #### Report on the Fargo2 list
        Please report success or failure on the Fargo2 list.
        If there are problems, remember to provide all the information someone would need to help you.
    April 5
    April 4
      Fargo 1.53
        A couple of minor changes related to watched outlines.
        1. If the user is hooked into my Fargo Publisher server, pub.fargo.io, and has one or more watched outlines open, we use a new server just for checking for changes instead of using the main server. Just want to lighten the load on the main server, to keep it nicely responsive.
        2. If you aren't actively using Fargo, we don't check watched outlines. The rule is if you haven't typed anything in 5 minutes, we don't check. If you want it resume checking just type something.
        Watched outlines are central to using Fargo in a workgroup.
        #### How to update
        If you're running Fargo in a tab in the background, it would be helpful to me if you would reload the tab to get the newest version running. This will lighten the load on my server if everyone does it, because the new version has an important optimization. Thanks! :-)
  March 2014
    March 24
      Fargo 1.52
        All the changes in 1.52 are in the stream template, and a little addition to Fargo's CMS to support the new stuff. And all the changes are fairly technical.
        #### Maps
        Maps are the big 1.52 feature. Here's a narrative.
        You can use maps in the backgrounds for days by attaching attributes to the headline for the day. This feature will get separate documentation.
        #### How to install
        Reload http://fargo.io/ and verify the version under the dinosaur is 1.52.
        #### What's changed in the stream template
        New fonts. Ubuntu and Vollkorn. Per the recommendation on this page. Ubuntu is an old favorite
        Thanks for Ken Smith's suggestion to include the italic and bold versions where available.
        Fixed a bug where if you went to a permalink without subs (example), it would flip the wedges on all items that did have subs. A jQuery newbie mistake.
        The title of each page now has the site name in square brackets. The home page is given the name "home," it would otherwise be the empty string.
        Updated the fargoTemplates repository on GitHub.
        #### What's new in the CMS
        There's now a connection between the attributes on the day page in the outline and the <div> representing the day in the rendered HTML. This is how the data is transmitted from Fargo to the page for the new map feature.
        For example -- here's the attributes on the main headline for yesterday's Scripting News. You can see it completely specifies the map that's displayed behind the day's content on the site.
        To see how that's reflected in the HTML data structure you can open it in a debugger, or peruse this screen shot. The correlation is pretty clear. All the unusual attributes are present. We don't bother with the atts that every headline in Fargo has -- created, name and text. Anything the user has added, however, is transmitted, and of course available to the JavaScript code running in the page. This is how we make the linkup with Google Maps as the page is loading.
        It took a while to figure out how to do this mapping, but this is exactly why the data-xxx feature is in HTML, what's interesting is how nicely it maps onto the structures we're already maintaining in the CMS. The worlds match up nicely. ;-)
    March 23
      Overriding font choices
        A good question on the smallpicture-web list.
        How can I use a Google Web Font in my Fargo website?
        There are probably a few ways to do it, but imho the easiest is to add the font includes and new style declarations in a <%customStylesScripts%> glossary entry. This is included in every template, after all the other styles and scripts, in the head section. So you can override anything, in theory, by putting it in that glossary entry.
        Here's an example site that illustrates.
        Here's the OPML source for the site. <%reader ("https://dl.dropboxusercontent.com/u/36518280/misc/fontOverrideDemo.opml")%>
    March 21
      Noteblogging tips
        1. It's better not to put links in headlines with subs. It makes clicking on the headline have two meanings, and this can be confusing. If I find I want to add notes under something that's already linked, I add a new headline, and moved headline with the link under it.
        2. If you want something to be in the feed, you have to use the + icon to create it. Some people are apparently creating new items by pressing Return. I do it myself, without thinking. Those items will not be in the feed.
      Fargo 1.51 released
        For now, if you want to create a noteblog, follow the instructions on the Testing 1.51 page.
        I'll merge those instructions in with the regular Fargo Docs, shortly.
        Updated the templates repository on GitHub. v0.42.
        Update: The Fargo Docs site now has a Noteblogging howto page.
    March 18
      Testing Fargo 1.51
        These instructions have been replaced by a page on the Fargo Docs site.
      Updated outline template
        The default outline template got a couple of updates.
        1. The slogan at the bottom is now hidden. It's still there, and if you want to bring it back, add this bit of CSS in a #style directive: .spSlogan {display: inline;}
        2. You can now put a background image on an outline page. Add a backgroundImage attribute to the title headline. Its value is the URL of an image. It should be pretty big. This page uses the outline template and has an image.
        I updated the GitHub repository with the latest versions.
        #### The #style directive
        If you haven't checked it out yet, it's really sweet.
        Basically you can add CSS styles at any level -- in your cmsPrefs.opml file, or on an individual page. It's one of the coolest new CMS features in Fargo 2.
        See the page on the Fargo Docs website.
    March 15
      The new Scripting News
        This evening I flipped the switch, and now "Scripting News" has been transformed into a new kind of blog -- something I call a noteblog.
        The site is edited with "Fargo", of course.
        There's a new template, called "stream" -- and a new nodetype -- "idea."
        You will be able to create and edit sites like this, once the new version of Fargo is released.
        #### Example page
        Here's an example of a day page, today's page.
        #### Release in stages
        We'll do the release in stages, as was done with Fargo 2.
        First I'll post a pointer to the Fargo 2 list. Adventurous people will be able to try it out. Report problems -- and there will be problems, that's for sure.
        There's also some new art in feeds that's been necessary. I've been discussing it on Scripting News. The changes will cause problems with feed readers. But it will also enable new kinds of feed readers. This is important for the future. ;-)
        There's also a new bookmarklet, that once installed and set up, makes it easy to shoot a link to into a designated Fargo outline. I'm using it now, and it works like a dream.
        #### Important point
        You do not have to use these features!
        If you're happy with the way Fargo works, then I'm happy too.
        Sometimes people think change will break things, but I try really hard not to do that. I'm a user too, and I really hate breakage. ;-)
        "curly"
    March 12
      Fargo Publisher 0.92
        Stephen Pond reported a problem with links in the crumb trail of his blog.
        There really are two problems here, one with Fargo CMS and one with "Fargo Publisher".
        This evening I fixed the problem in Publisher.
        When you go to this address: swppond.smallpict.com/2014/03 it would fail, because there isn't an object named 03 at that path. But servers should be a little more forgiving, and see if it's possible to interpret 03 as a folder. The rule is this: if it contains a file named index.html, we serve that file. That's what the author intended us to do.
        Fargo CMS should generate a / at the end of the URL, then the server-side workaround wouldn't be necessary. But it's a good thing for the server to do anyway.
        I updated the GitHub repository and added a worknote.
      Phone-ready templates
        I just updated the new default versions of the outline, bloghome and medium templates in the global prefs file. To get the latest version of this file, reload the Fargo app.
        Also updated the templates in the GitHub repository.
    March 7
      Fargo 1.51
        Fixed + in settings dialogs per Andy DeSoto's report.
        New # directive for fixing the menu at the top of the screen, #flFixedMenu, defaults true, you can turn it off to preserve the original behavior. It's best when the menu is always accessible no matter how far you've scrolled.
        Fixed implementation of link nodetype in wordpress connection.
    March 5
      Voiding the snarky slogans
        On the smallpicture-user list, Andy DeSoto asks a great question about the built-in slogan macro. He wants to know where it's defined. That isn't the issue, if you don't like the way it works, you can override it, by writing your own version of the macro, and putting it in your cmsPrefs.opml file.
        If you look in my cmsPrefs.opml file, which you can view on this page, you'll see that I've defined several macros. If you define your own #macros table, and put a script in there called slogan and have it return the empty string, you'll basically void the built-in routine.
        Here's a screen shot of the macros table with this new version of the slogan macro.
        Here's the docs page on defining your own macros.
        And to answer the original question -- the built-in macros really are built-in, they're not in a place that you can edit them.
    March 2
      Fargo for Frontier people
        #### Background
        Fargo's CMS is the continuation of a series of content systems developed at UserLand, going back to the mid 1990s.
        The first was the website framework, which grew out of the 24 Hours project.
        There were thousands of people doing websites with it.
        The first blogging software was developed in Frontier's CMS.
        I used it for "Scripting News", and Jorn Barger, among others, used it for his first blog, Robot Wisdom.
        UserLand developed XML-RPC, RSS and OPML to create networks of software and content.
        The website framework led to Manila and Radio UserLand, and almost 20 years later -- Fargo.
        #### Who this is for
        I'm writing this for the people who used one of these earlier systems at a programming level. I want to show how this is an evolution of the ideas in the earlier systems, even though it's a wholly new codebase, written in JavaScript and running in the browser, hooking up to file storage using Dropbox, and flowing the content to the public web through software running in node.js
        #### Example website
        Here's the outline behind the Kim Parker blog website. It's a simple example site that shows how the basic ideas of Fargo's CMS hang together. <%reader ("https://dl.dropbox.com/s/ge8ql807di0rzkt/kimParker.opml")%>
        #### Hierarchy and attributes
        The Frontier CMS used the hierarchy of the object database to project values over the content as it was rendered. So a #template, for example, could be overridden by placing another #template at a deeper level.
        The same hierarchy works in Fargo but there is no object database. But each outline acts like an object database. It can contain lots of documents, each of which is rendered onto its own HTML page.
        In Fargo, as in Frontier, any headline node can have as many attributes as you want to put on it. These attributes also act like #directives.
        Frontier had a pagetable, and so does Fargo, and it's built in exactly the same way.
        #### Values come from 3 places
        In Frontier, all values used in rendering a page come from the same "root" or object database. Values from other databases can be included, but only through scripts that you provide that run as the page is rendered.
        In Fargo, we made this richer.
        1. Default values come from an OPML file that I maintain. Every copy of Fargo loads this file when the app initializes. This is where the default templates come from. There are global glossary elements that are available to all page renderings. In the 90s I played around with the idea of a global glossary, but it never came together. It works perfectly in Fargo, and it's not just a global glossary, it's a global everything. It took a long time to figure out how to do it, but it's in there now.
        2. After that Fargo loads a file from your Dropbox folder called cmsPrefs.opml. It works exactly like my global file, but it's only broadcast for your own renderings. This lets you set up structures, scripts and values that are shared for all the pages you render on your system. You can override anything I have put in the globals file.
        3. The attributes from the file you're rendering content from.
        #### Filter scripts
        Frontier's website framework had three types of "filter" scripts -- firstFilter, pageFilter and finalFilter. Fargo only has finalFilter, however if there is a need for a firstFilter script it will support it.
        #### Glossary
        Glossaries in Fargo exactly as they did in Frontier.
        #### Includes
        Fargo supports includes everywhere, support is baked into the framework at a very low level and they are transparent. This gives you an easy way to share definitions with other users. However, be careful, includes can slow down your rendering, significantly.
        #### Complete docs
        Review the docs for Fargo's CMS for other features that are new in this framework.
      RFC: Fargo's Markdown support
        I thought now would be a good time to ask if people who have experience with Markdown have any ideas for Fargo's implementation.
        How is it working for you?
        Are there any problems, features you have to work around?
        Any feedback would be welcome.
    March 1
      Fargo 1.50
        1. RSS feeds now have rendered Markdown. Glossary elements from the global glossary and from cmsPrefs.opml are evaluated. See the Rendering for feeds post for entities that are not evaluated in feed rendering.
        2. Fixed a few more icons from the Font Awesome 4.0 integration.
        3. The Open by name command in the File menu now remembers the name of the last opened outline.
        4. Fixed a layout problem in the Outliner menu where command key names would overwrite the name of the command. Widened all the menus by 20 pixels.
        5. Fixed a problem in the default outline template where the wedges that expand and collapse the comments would be invisible.
        6. Added a <%slogan ()%> to the bottom of the page in the default outline template.
  February 2014
    February 28
      Rendering for feeds
        In version 1.50, coming in the next couple of days, Fargo will do a lite render of RSS descriptions.
        #### What "lite" means
        1. It passes the text through the global glossary.
        2. It passes the text through your cmsPrefs.opml glossary, if you have one.
        3. It passes the text through the Markdown processor.
        #### What's unprocessed
        This will help the text in the feed look good in whatever RSS apps your readers are using. But it will still leave macros unprocessed, and it won't use any local glossaries. And the pagetable elements, if you reference them, will be unevaluated.
        These things are difficult, but not impossible. However there are lots of other things that are higher priority. :-|
        Also, you have to watch out for glossary items that depend on the runtime environment of Fargo-generated pages. Anything that depends on Font Awesome being present, or Bootstrap Toolkit, won't work. I do that in my smiley characters. ;-)
        But the cheesecake glossary entry should render fine.
        "cheesecake"
        #### Sunday or Monday
        I want to spend some time using the new version myself (I'm using it now) before making it part of the main release. This is tricky stuff and I want to be sure I got it right.
      Font Awesome 4.0 support
        The only change in Fargo 1.49 was that Font Awesome 3 has been replaced with version 4.
        This was not a small change, unfortunately, even though the goal was to make it appear as if it was a small change. Please watch for breakage.
        While I was working in this area I made it so that the left and right arrow keys move between panels in the Icon Chooser dialog (accessible from the Outliner menu in Fargo).
        I also updated the GitHub project.
        #### Editorial
        Font Awesome is still very awesome. :-)
        But I wish they wouldn't rock the boat so much.
        We've baked in support for this excellent toolkit deeply in Fargo. Such deeply integrated things are not easily replaced, especially when lots of small seemingly unnecessary changes are made.
    February 27
      Fargo 1.48
        #### Narrative
        As Fargo was booting up, if there was a watched outline in tabs.json, it would fail.
        Frank reported that the icons wouldn't show up, but when I reproduced the problem it was even more serious -- the app itself didn't load.
        The problem was introduced when I added "Fargo Publisher" support to Fargo. When the app is booting, appPrefs hasn't yet been set up, so when it tried to read the watched outline, it would fail. I added some defensive driving to the boot-up process to delay the read until the app was fully initialized. But there was some other initializing that wasn't happening, which would cause yet another failure.
        #### Solution
        I solved the problem by having Fargo use the default server to read watched outlines as it's starting up. Once the app is running, it uses the server that's in prefs.json.
        #### Thanks!
        Thanks to Frank McPherson for the excellent report.
    February 25
      Feature: Paragraph-level permalinks
        If you want paragraph-level permalinks in your blog posts, there's a new directive, #flPgfPermaLinks.
        If you set it to "true" your posts will have them, "false" to turn the feature off.
        They are off by default.
        If they're on, each paragraph in your blog post will have a small purple hash sign, that links to the paragraph. If a reader wants to point to a specific paragraph in the post, they can use the URL from the hash sign.
        The link is formed from the first characters of the first five words in the paragraph. You can move the paragraph around on the page without breaking links. However, if you change one of the first five words in the paragraph, links to it will break.
        If you want the feature on by default for your websites, you can put the directive in your cmsPrefs.opml file.
        #### Example
        #flPgfPermaLinks "true"
    February 23
      Experiment: re-mapping keystrokes
        For some Fargo users, the standard key mappings get in the way of the normal functioning of the browser. Now we have a way to disable individual key mappings, or add new ones. It's very geeky, so I'm calling it an experiment to see if it helps.
        #### How to
        Suppose you want to disable Fargo's mapping for Cmd-[ for Promote.
        1. In the System menu, the one at the right edge of the menu bar with your name as its title, choose the Settings command.
        2. Click on the Code panel.
        3. Enter this bit of code: concordKeystrokes ["meta-["] = "";
        4. Click OK.
        5. Reload Fargo.
        6. Press Cmd-[ on a headline with subs. If it worked, it should do nothing.
        Screen shot.
        #### Standard mappings
        Here's a list of the standard key mappings in Fargo.
        <%listConcordKeystrokes ()%>
        #### What meta means
        On Macs, the "meta" key is Cmd. On Windows and Unix it's Control.
    February 22
      Please subscribe to this feed
        If you're a regular Fargo user, please subscribe to this RSS feed.
        http://fargo.io/blog/rss.xml
        I will try to post notes about new features and ideas on this blog.
        If you like to read my thoughts about movies, weather, the Knicks as well as tech, you could also subscribe to the Scripting News feed. I will also talk about Fargo there from time to time, but it's a regular blog so, you have to endure the other stuff too. ;-)
        "cheesecake"
      Fargo 1 named outlines
        If you have a named outline from Fargo 1, you should still be able to edit it and update it and have the results flow through to the web.
        In fact, it would be a good idea to open those files now, have a brief look around and then do a Render All Pages from the File menu. This would cause your site to update into the new scheme.
        Fargo 2 is close enough to Trex that your sites should render without too many problems. Mine certainly did. (That was one of the goals of Fargo 2's CMS, to run Trex sites.)
        #### Test case -- Anton's blog
        I hope Anton doesn't mind, but I saw his blog get updated, and saw it had problems. It's a Fargo 1 named outline, that means it uses features that were in Trex, and not all of them work in Fargo 2, and at least one of them works differently. This is accounting for the not-satisfactory look of his site.
        1. On the Differences from Trex page, we note that the #bootstrapTheme directive changed in Fargo 2. Anton's site is using the old definition. This means that when the page loads in its stylesheet it gets an error, so we're seeing the unadorned text on the page. (Update: I fixed this in Fargo, if you reload the app, and re-render the page, it should look good.)
        2. He's using a feature in menus that isn't implemented in Fargo 2 that was implemented in Trex, the ability to put the text of a page under a menu item. I agree that it's a nice feature, but it's harder to do in a static rendering CMS, so I didn't try to do it in Fargo 2. The answer is to create a top-level About page, and link to it from the menu item. You can see an example of this in the Kim Parker website source.
    February 21
      Macros in Fargo 2
        Here are some examples of what programmers can do with macros in Fargo 2.
        Anything that appears inside <% and %> is considered a macro, and it runs when the page is rendered. The result of running the macro appears in the rendered page.
        Macros are written in JavaScript.
        The stuff inside the brackets is just a JavaScript expression, that can call any number of builtin verbs, any standard JavaScript functions, or make HTTP requests using the http.readUrl verb.
        If you enter <%2 * 12%> you'll get <%2*12%> in the page.
        Fargo has an array called snarkySlogans that can be useful for testing this feature.
        <%snarkySlogans [5]%> gets you the sixth item in the array, or "<%snarkySlogans [5]%>"
        And here's a cute macro that lists all the snarky slogans:
        <%s="<ol>"; for (var i=0; i < snarkySlogans.length; i++){s += "<li>" + snarkySlogans [i] + "</li>"}; s + "</ol>"%>

        <%s="
        "; for (var i=0; i<snarkySlogans.length; i++){s += "
        " + snarkySlogans [i] + "
        "}; s + "
        "%>

        Also: You can define your own macros, with parameters. (This is not a snarky slogan.)
    February 20
      Welcome to Fargo 2!
        The version number in the right margin still says 1.47 and the red BETA is still there, but -- when you go to fargo.io you now get Fargo 2. Fargo 1 is archived, hopefully it will remain runnable for a long time to come. But the future is here, now -- we're all running Fargo 2.
        Because it's a beta, keep an eye out for problems, and if possible back up your outlines outside of your Dropbox folder periodically to be sure you don't lose any data.
        The big new feature in Fargo 2 is the CMS that's baked into the app.
        There's also a companion server app called Fargo Publisher, that runs in node.js. It's open source. You can run it for yourself and for other users, and are encouraged to do so. It's still a bit unpolished and in development, but if you're an adventurous technical sort, it should be an interesting project. I know I'm finding it very interesting running my server.
        I'm going to spend a couple of days reviewing the docs, making changes as needed to reflect the new status of Fargo 2. If you spot anything, just add a comment under the article.
        "cheesecake"
    February 17
      Fargo Publisher 0.88
        A new configuration option, allows you to specify whether you want Publisher to redirect to content stored on S3 (the default, and current behavior) or serve it directly.
        To set the option on a "normal" Unix server:
        export fpRedirect=false
        To set the option for a Heroku app:
        heroku config:set fpRedirect=false --app your-app-name
        I've set the fpRedirect option false on smallpict.com, possibly as an experiment. However I'm pretty sure the server will be able to handle the extra work of serving the content instead of redirecting, and it makes things simpler all-around, which of course is a good thing.
        What does this mean in practical terms? Here's a post on my test site, the one I used to develop the CMS. Because the redirect feature is off, the URL doesn't change after you click the link.
    February 13
      Fargo 1.46
        Until this release, your RSS file was not written out to the Publisher server.
        Now, if you do a rendering, it will generate the RSS file and it will be uploaded to your site along with the HTML files.
        Next thing to look at -- all the automatically-generated links to the RSS files. They should point to this file, not the one in your Dropbox folder.
      Fargo Publisher 0.86
        This release has support for "watched outlines" as used in the Fargo for Workgroups feature.
    February 12
      Fargo Publisher 0.84
        Lots of new stuff, fixes -- it's very solid now (knock wood).
        It logs every hit, and catches errors, not relying on the OS to restart the app.
        I've caught a bunch of problems this way.
        If you're running an older version I highly recommend moving to 0.84.
        The worknotes page on the GitHub site logs the changes, at a high level.
    February 11
      Fargo Publisher 0.80
        A new release of Publisher with two new API endpoints.
        1. /httpreadurl -- does an HTTP request for Fargo.
        2. /status -- returns a status record in JSON for monitoring apps.
        If you're running a Publisher server please update asap. I'm going to quickly convert Fargo to use the httpreadurl endpoint, so your Publisher installation must have this feature.
    February 10
      New release of Fargo Publisher
        Ken Smith did something surprising, he got a Fargo Publisher server up and running on his own. I hadn't anticipated that anyone but the most adventurous programmer would try this, at this stage in the development process. But that's because I know too much about how unfinished it is. Ken didn't know, so he went ahead. And to my surprise, it kind of worked. ;-)
        It's good, because it helps me get organized to finish this part of the Fargo 2 project. You should be able to switch over to a new back-end without any concern. And operating a server should be something a poet can do. If Ken can get over the Heroku side of it, I can make the Fargo side of it work almost perfectly (no software is ever perfect, of course).
        So I've fixed one of the biggest remaining problems -- redirected from an outline name to the website rendering for that outline. You should be able to type kim.smallpict.com into a browser, and be taken to Kim's site. That used to work in the Trex days, and it works for smallpict.com only because I jury-rigged something temporary to make it work. And if you do it with Ken's domain I'm pretty sure it doesn't work.
        However, in Fargo Publisher 0.79 that should be fixed.
        #### Installing 0.79
          Download the Fargo Publisher folder from GitHub as you did before, and replace your old copy of publisher.js with the new one.
          At the command line, update the running version of the app with these commands.
          git commit -a -m "Update"
          git push heroku master
        #### Telling Heroku about it
          Assuming the domain you're managing is bumpy.org, you'd issue this command"
          heroku domains:add *.bumpy.org
          Of course *.bumpy.org should be mapped, via DNS, to be a CNAME for the domain of your Heroku app.
        #### Testing
          The way to test it is to do the following:
          In Fargo, open an outline that's being managed by your Fargo Publisher server.
          Put the cursor on a document.
          Click the Eye icon.
          Did it work?
    February 7
      Fargo 1.44
        Brian Milby reminds that the Name Outline command needs attention.
        1. Now, if you click OK with a name that's less than 4 characters, Fargo beeps and puts up a message in red saying the name is too short. You can click Cancel if you want to close the dialog.
        2. The prompt is shorter, mentions the CMS, and links to the docs section on content management and Fargo in a Workgroup.
      Where Fargo 2 sites are hosted
        An important part of the process of developing the new CMS was coming up with a strategy for hosting Fargo sites that was likely to work for users, and didn't have me hosting your sites. Believe it or not, that took almost as much time as doing the new CMS (which was a from-scratch rewrite, not a port).
        We looked at several approaches. The discussion is in the archive of the Fargo2 mail list if you want to see what we considered.
        What we're left with is two ways to do it, but one way that I think will work better than the other, especially in the short term.
        #### Synching
          Syncing from the html sub-folder was the first method I implemented. It still works. The problem is that there are no services that are a perfect match for this capability. Part of the problem is a Dropbox limit. An app can have access to your entire dropbox folder, or to an app folder. You can't give access to an app to a single sub-folder nested inside another app's folder.
          Eventually we stumbled across the Pages service from GitHub, which is a pretty close match to the ideal service that would fill in for Fargo's ability to generate a folder of static HTML files. There's a howto that explains.
          It's possible that better solutions will come along. Or Dropbox will add the ability to share a folder between two apps, making an almost-ideal solution possible. The best solution would be for Dropbox to let you put a domain name on a folder, and it could manage the serving. That would rule, and make any other approach look nowhere near as good.
        #### Fargo Publisher
          When it became clear that syncing wouldn't provide an easy-enough answer for most Fargo users, imho -- I bit the bullet and wrote a web service in Node.js that Fargo could hook directly into, and it would manage the storage of people's HTML in an S3 bucket, beta.fargo.io.
          By calling it beta.fargo.io, I hoped to signal that it's a temporary solution.
          The Fargo Publisher app is on GitHub, it's available under the MIT License, the most liberal open source license. My hope is to establish the protocol that Fargo uses as a basis for interop among a group of implementations, and encourage people to start services to host their own content, and to offer hosting to other users.
          That's one of the reasons I wanted to come up with an approachable how-to for deploying Fargo Publisher. With the generous help of Eric Kidd, we now have that how-to for Heroku, which is a subsidiary of Salesforce.com. They seem really reliable, and for a low-volume server it's free. Can't argue with that! :-)
          Once you have a Fargo Publisher server up, it's a simple matter to get your copy of Fargo beta to talk to it. Visit the main Settings dialog, off the System menu in the upper right corner of the screen, click on the CMS tab, and change the server from pub.fargo.io to the name of your server. Your changes should start flowing through that server immediately. This is still a beta, so there may be problems, but now is the time to shake them out.
          Here's a screen shot of the dialog.
        #### Pointers
          See also: Why Fargo 2 technology is interesting.
          And: Heroku How-to.
    February 6
      Medium template released
        Update: There was a problem with this release, and I had to temporarily remove the medium template from the standard set. The outline is still in the fargoTemplates repo. I'll revisit this when I don't have a current piece that uses this template. ;-)
        I use a template for a type called medium to publish special blog posts on Scripting News, such as this one.
        When I did the first release of the templates as open source, a few days ago, I forgot to include this one in the release because it was in a separate project, being managed not as one of the core templates.
        When I realized this later, I couldn't think of a reason it shouldn't be out there, maybe people can improve on it. And I'm sure some people would like to use it.
        As with all the other templates, you can find the original source in OPML and plain text in the fargoTemplates repository on GitHub.
        With this release you should be able to use this template by changing the type attribute of your document to medium.
    February 2
      Why Fargo 2 technology is interesting
        Note: Please don't point to this piece -- we're not ready to talk about this publicly yet. Soon! ;-)
        Fargo 2 is an outline-based content management system for the web. Most CMS software is configured in Model #1 in the diagram below. Fargo 2 is configured differently, and this is a new way to do it with different economics.
        In the traditional model for content management, Model #1 in the diagram, most of the hard work is done on the server and there's a lightweight client written in JavaScript, that runs in the browser. The client assists the user in navigating a menu system for setting options and editing articles and images.
        Because the heavy lifting is done on the server, and it's managing lots of users' sites, the servers are expensive. Huge data centers, with air conditioning and staff.
        A different model has always been possible, Model #2 above. My earlier company, UserLand, pioneered this with Radio UserLand in January 2002. It put the heart of the CMS on the user's machine, in a separate app you had to download and install. At the time there was no "cloud" for us to tap into, no Amazon S3 or EC2, or Dropbox, for us to leverage. But it worked! Radio was a popular product, even though the user was running a little server on their desktop (and most had no idea they were).
        Today we can do even better, because the browser running JavaScript is a very powerful environment. Installing a CMS on your machine can be done simply by loading a page. No software to install. It's really amazing when you think about it. (But not so amazing if you think how long it took to get here.)
        Model #2 has very little downside today compared to 2002. The cloud is ubiquitous and reliable. The software runs in the browser, no app to install. And today's machines are hugely powerful and can render a modest size website in a second or less (really). It's fast.
        The new Fargo, the beta that you're using, does almost all the work that a server-based CMS such as WordPress and Tumblr does. It relies on a tiny public component, called Fargo Publisher, which has been released under the MIT license. The protocol it uses is open, so other back-ends can be implemented, and other "static" software like Fargo can use it to help the user publish their work. I will document the protocol when it settles down, which will happen soon.
        We're going to hack at making it easy to run this server. Right now it is not easy, but there's no reason it can't be. Then you can truly be independent and I think some amazing things can happen.
        Please ask questions if you have them, in the comments below. I want to be really effective at communicating this. A lot of good will come from it, I think.
    February 1
      Heroku testing
        Thanks to Eric Kidd, I've got Fargo Publisher working on Heroku.
        If you want to give it a try, this is what you can do:
        1. Choose Settings from the System menu.
        2. Click on the CMS panel.
        3. In the Server field, enter: fargopublisher.herokuapp.com
        4. Click OK.
        Here's a screen shot.
        You should be able to edit named outlines, give names to outlines.
        Verify that the changes make it to your beta.fargo.io site.
      fargoTemplates on GitHub
        I just created a repository on GitHub with all the built-in Fargo 2 templates.
        When I update a template, as before, the change will be reflected in the globals outline, but now it will also update the repository.
        You are free to fork them, modify the result and redistribute.
        I licensed them under the GPL, which means any modifications you make have to also be released under the GPL. Read the license for the specifics.
  January 2014
    January 31
      Here we go!
        Earlier today I put a link to the Fargo 2 beta in the message of the day, and I just posted an announcement to the smallpicture-web list. The next phase of the beta is underway. Thanks for your help and patience in the first part of the beta! :-)
      Fargo 1.43
        Lots of little cleanups and fixes.
        1. The problem Andy DeSoto reported has been fixed. The site URL in his setup was missing a closing slash. People will do that, so we look for it, and add it when computing the URL, if it wasn't there.
        2. The Render icon in the left margin now only renders the cursor page, none of the subs or parents, and does it immediately without waiting to run in the background thread.
        3. Did a small optimization in the CMS and did some performance testing. This thing flies. I can't believe how fast it renders. Big thing however is that in the current implementation includes really can slow things down. If you're seeing really slow rendering that may be why.
        4. Fixed a bug in presentation nodes now they render properly.
        5. Fixed a lot of problems in the Kim Parker website, which now works. It's our basic demo site, so if it had problems so would our first users.
        6. The default type is now blogHome. You can of course override it by putting a directive either in your cmsPrefs file or at the top level of a website. This is again for the first-time user experience.
        7. Fixed a bug where the Next arrow on a post would be disabled even though there is a next node. This would happen for index pages that don't have a type att. They do have next nodes, so I had to add an exception to the storyVisit routine for those nodes.
        8. The Bloatware site was redone, and static-ized. It's the fictitious company that Kim works for.
    January 29
      The plan
        I've got the back-end working in node.js on a new server running on EC2.
        I've got people I can ask questions of about running node.js on my own server.
        Fargo 1.42 seems to be running pretty smoothly.
        There is one thing I want to take a look at -- performance. Some sites, notably the Fargo Docs site, are very slow to render. So slow that I think there's a bug in there, or something that desperately needs optimizing. I want to find out what's going on before proceeding. It's hard to know what the ramifications are until we get to the bottom of it.
          Update: I was using includes in the Fargo Docs outline. Not a lot of them, but three of the big sections were linked to docs that I was editing in the OPML Editor. I had to undo the includes for another reason, and then the performance improved dramatically.
        On the other hand, this site is very nice and peppy! Weird.
        Please review the about page for the public beta. Comments welcome.
        Anyway -- net-net, I think we'll be in public beta on Fargo 2 before the SuperBowl.
        Yehi! :-)
    January 17
      Fargo 1.39
        #### More powerful Render Page command
          When you choose Render Page from the File menu, Fargo not only builds the parents and the bar cursor headline, it now builds any documents subordinate to the bar cursor headline.
          This means, for example, I can build just the Content Management section of the Fargo Docs, without having to rebuild each page manually, or building the entire site. Both were time-consuming and annoying. Fixed.
        #### Render icon in the left margin
          The Render Page command is a biggie, and it deserves a little advertising in the left margin. I chose the Share icon from Font-awesome.
          There were other possible choices, for example the world icon, to indicate that it's being published to the web.
          I went with Share because that seemed closest to where this command is today, and where it's likely to go in the future.
        #### Interesting story to go with this change
          As you may recall, Dropbox went down just after I had made a change to the CMS on the 11th, and wasn't able to test it. I was going on a trip to New Orleans the next day, so I commented the change, just to be safe (it almost worked, but not quite). The fix was easy, and now the new version is deployed.
    January 10
      Cleanup after blogHome changes
        Cleaned up breakage after changes in implementation of index type and the addition of blogHome type. Now we can have typed nodes that have subs that are typed (i.e. index nodes and blogHome nodes).
        Generating URLs to these objects becomes more complex in these places:
          When generating URLs in blogHome pages.
          When the user clicks on the Eye icon.
          When generating URLs in index pages.
        Have a look at the new Example 16 to see what I'm talking about. That's where the breakage revealed itself. I pointed to the examples page, so you could see how a link to Example 16 is different from the links to other pages. That's because it has subs that are docs.
        I suspect that Jeffrey saw it as well in his index pages that were subordinate to blogHome pages.
        However, I think it all should work now. Really ready to go on vacation and put all this behind me. ;-)
    January 9
      Creating an index page anywhere
        Jeffrey had a good question.
        Suppose the home page of my site is a blogHome page.
        Now I want to have an index on one of the lower-level pages.
        There was no way to do this. Either the top page is an index, or none of the pages are.
        This is obviously not a good thing.
        Now, if you set the type of any page to index it will render as an index page.
        You don't have to supply an index type template, because at the same time I added a bit of code that says that if a page has a type for which there is no template, use the outline template. This solves a bunch of other problems too, and can't result in breakage (something I'm starting to worry about) because there were no pages that rendered without a template previously.
        I also changed the defaults for index pages so that the stories and dates would be off by default. These features were there in a vain effort to get the index type to do what blogHome type does. Now that we're not trying to do that, it made sense for the defaults to be set up for the simple case.
    January 8
      Bug fix: Autosave-off, no RSS
        It was easy to see why there was no RSS feed or rendering happening when you have auto-save turned off, it wasn't doing it. This is of course because I always have autosave turned on. I suspect we'll find many other problems like this in the weeks to come. ;-)
        Anyway, I'm typing this with autosave off, and the console window open, and nothing is happening, as you would hope. Now I'm going to choose Save from the File menu and see what happens.
        Everything is rendered and the feed is built. I'd say the problem is licked.
        Note to testers: See why it's important to say what you did? Somewhere in that narrative would have been "I chose Save from the File menu" and that would have pointed me right at the problem, because it isn't something I ever do.
    January 7
      Today's changes
        Bloghome sites need titles
          It was wrong to remove the titles from the blogHome template.
          It's just the home page of the site that doesn't need the title.
          It's assumed that the menu "brand" will contain the site name.
          All the other pages point to this page.
          I made this work through a runtime JavaScript when the page loads.
        Crumbtrail review
          The crumb trail was broken on pages other than the story page.
          I radically simplified the code.
          It works now.
    January 6
      Fargo and naming/storage systems
        This post explains how Fargo 2 connects with the naming system.
        There are three points of connection, two for the Name Outline command in the File menu, and one for the rendering process in the CMS.
        This documentation is here so you can see how the process works. Don't call these endpoints, they're just for Fargo to call. Thanks. ;-)
        #### 1. Is the name available?
          URL: http://namer.smallpicture.com/ajax/isNameAvailable
          Param: name, a string
          Returns: An HTML snippet suitable for display saying whether the name is available.
        #### 2. Grab this name
          URL: http://namer.smallpicture.com/ajax/newOutlineName
          Params: url of the associated OPML file, name, both strings
          Returns: JSON struct indicating whether it worked.
          Note: It's a JSONP call, the routine name is getData.
        #### 3. This outline updated
          URL: http://fargoajaxsupport.smallpicture.com/ajax/pingPackage
          Params: url, a string
          Returns: Nothing worth looking at (at this time).
          Note: The URL is what was returned by the grab this name call. The OPML file must contain a <head> element, linkHosting, that points to a package file. You can see what one looks like in the #hosting folder of the Fargo app folder.
          More docs will be forthcoming, for sure.
      Other changes today
        Starting the transition of Scripting News to the new CMS. Reviewing the original site and what Fargo produces, and hacking at the differences.
          I archived the outline for 2013, I'm not going to try to convert anything before 2014. The OPML is preserved and the static web pages are exactly where they belong.
          I had already archived the 2013 entries for the Fargo blog in this outline. Again, I'm not re-rendering these pages. They are as they are. ;-)
        Problem with Render Page command, getPathToBarCursor is not defined. (The name of the routine had changed, but the code did not.)
        Took the <h2> title out of the blogHome template. It's not supposed to be there. (Look at the current Scripting News home page, no title.)
        A new Overrides panel in the Outline Settings dialog, with one initial item in it, type. You can say what type the + icon in the left margin creates. So globally you could have it be outline, and in just one website it could be a custom type.
        The Name Outline command works once again. It now turns on the two rendering preferences in the CMS panel of the Outline Settings dialog. Named outlines that don't render don't make much sense.
      blogHome type makes a comeback
        I was trying to sort out the various problems with index pages, and realized I had created something too complicated to debug, or to document, or use for that matter.
        This is a common trap in developing CMSes. One extra option too many. Even I didn't understand how it worked. (And I didn't want to.)
        So I solved the problem the same way we did in Trex...
        We once again have a blogHome type and a template to go with it.
        As with Trex, put a #type "blogHome" at the top level of your outline.
        By default there are 10 items in each blogHome page, but you can change that by setting #blogHomeItemCount.
        I've re-rendered the Kim Parker site with the new setup, and you can look at the source to see how it works.
        I've also re-rendered the Fargo Docs site, which is the one that makes use of index pages. It was a tweak to those pages that broke the camel's back and made the index type unsuitable for weblog home pages.
        Whew! :-)
    January 4
      2013 archived
        I just used the Archive command in the File menu to put the entirety of 2013 to rest as far as the Fargo blog is concerned.
        Now we start with a clean slate.
        A new year, a new Fargo.
        Onward!
#domain "fargo.io"
#menuname "fargoDocs"
#style
  white pres
    pre {
      background-color: white;
      width: 60%;
      }
#style
  testing
    .divOutlineNoMarkdown .spHeadText {
      font-size: 22px;
      }
    .divOutlineNoMarkdown {
      font-size: 20px;
      line-height: 150%;
      }
    .divOutlineNoMarkdown li {
      line-height: 150%;
      }
    .divOutlineNoMarkdown .ulOutlineList {
      padding: 0;
      margin: 0;
      }
    .divOutlineNoMarkdown .liOutline {
      list-style-type: none;
      margin-bottom: .5em;
      }
    .divOutlineNoMarkdown .liHasSubs {
      font-weight: bold;
      margin-top: 13px;
      margin-bottom: 13px;
      }
    .divOutlineNoMarkdown .liHasSubs ul {
      }
    .divOutlineNoMarkdown .liNoSubs {
      font-weight: normal;
      }
    .divOutlineNoMarkdown .spHeadText {
      }
    .divOutlineNoMarkdown .spOutlineIcon {
      margin-right: -11px;
      }
    .divOutlineNoMarkdown .aOutlineWedgeLink {
      color: black;
      }
    .divOutlineNoMarkdown .aOutlineWedgeLink i {
      color: black;
      cursor: pointer;
      width: .7em;
      position: relative;
      left: -.8em;
      }
    .divOutlineNoMarkdown .aOutlineTextLink {
      cursor: pointer;
      color: black;
      text-decoration: none;
      }
    .divOutlineNoMarkdown .spPermalink {
      }
    .divOutlineNoMarkdown .spPermalink a {
      text-decoration: none;
      color: purple;
      font-size: 10px;
      font-weight: normal;
      vertical-align: top;
      margin-left: 3px;
      }
    .divOutlineNoMarkdown code {
      display: inline;
      border: none;
      color: black;
      font-size: .85em;
      }
#glossary
  "cmsPrefs.opml"
    cmsPrefs.opml
  "this is a test"
    For the next sixty seconds this station will conduct a test of the emergency broadcast system.
    Had this been an actual emergency.
    Yes it's me I'm the Pride of Cucamonga.
    I can keep typing.
    Does it correctly remember the cursor?
    I want to keep typing.
    Hello this is another test.
#opmlFeed "http://fargo.io/blog/rss.xml"
#authorTwitterAccount "smallpict"
#type "blogHome"
#blogHomeItemCount "10"
#flHitCounter "true"
#counterGroup "fargoBlog"
#counterServer "http://counter.fargo.io/counter"