Looking for writing-related posts? Check out my new writing blog, www.larrykollar.com!
Showing posts with label computers. Show all posts
Showing posts with label computers. Show all posts

Monday, October 16, 2017 No comments

Tines 1.11.1

… is out. This is a quick bug-fix release, the PageUp and PageDown keys should now work properly (on Macs, use Fn-up-arrow and Fn-down-arrow). I’ve also merged the dev branch into the master branch on GitHub.

To make things more convenient, I registered tines-outliner.org and set it up as a shortcut to the repository.

If you aren’t familiar with Tines, it’s a console-mode outliner. It runs in MacOS X, Linux, and the Microsoft thing (using Cygwin). It’s unique in that it supports a “text” tag for entries, and so can differentiate between headings and body text. It can export to Markdown, HTML, *roff, and plain text formats. You can export your outline to Markdown and pull it into Scrivener. See Getting Your Outline into Scrivener (pt 2) for details.

Tines, and a few other outliners, has support for to-do lists (basically a collection of entries with checkboxes). That means you can use it to keep outlines, goals, snippets of scenes, and notes about your stories in a single place.

Compile?

Yes, the word “compile” is composed of the Latin com (together) and the English pile (a random heap, or hemorrhoid). So, yes,  compile means either to throw things together, or a multifaceted pain in the @$$. Still, if you need an outliner, it’s available!

I want to get back to working on an install package, at least for MacOS X. I’ll probably have to leave packages for the other operating systems to their own experts (not that I’m anything like an expert in MacOS X packaging, mind you).

Tuesday, March 21, 2017 No comments

Tech Tuesday: Roll Your Own Writing System, part 6: Jekyll


The series rolls to an end…

In Part 1, we had a look at Markdown and the five or six formatting symbols that cover 97% of written fiction. Part 2 showed how you can use Markdown without leaving the comfort of Scrivener. Part 3 began exploring eBook publishing using files generated from both Scrivener and directly from MultiMarkdown. Part 4 provided a brief overview to a different tool called Pandoc that can convert your output to a wider variety of formats, and is one way to create print documents for beta readers or even production. Part 5 described how to use MultiMarkdown’s transclusion feature to include boilerplate information in an output-agnostic way, and how to use metadata variables to automatically set up front matter.

Scrivener is an excellent writing tool, and we have seen how using it with MultiMarkdown only makes it better. But there are conditions where abandoning the GUI for a completely text-based writing system just makes sense. For example, you might want to go to a minimalist, distraction-free environment. You may want to move to a completely open-source environment. Or you might need to collaborate with someone else on a project, and Scrivener really isn’t made for that.

Don’t Hyde from Jekyll


Jekyll is the most popular static site generator. You write in Markdown—Jekyll’s particular flavor, which is similar to MultiMarkdown in many ways—and if Jekyll is running, it automatically converts your pages to HTML as soon as you save. It even includes a built-in web server so you can see what the changes look like.

If you’re on a Mac, installation is almost too easy. Drop to a command line, enter gem install jekyll bundler, and watch a lot of weird stuff scroll by. It’s as easy on Linux, if you have Ruby 2.0 or newer installed. On the Microsoft thing, there are some specific instructions to follow (I installed it on my work PC, no problem).

Once it’s installed, get going by following the quick-start instructions.

Organizing


Unlike Scrivener, organizing your project is on you. But there are a couple things that might help:

Each story or project should live in its own folder. Within that folder, tag each chapter or scene with a number to put everything in its proper sequence. For example:

100_chapter_1.md
110_arrival.md
120_something_happens.md
200_chapter_2.md
210_more_stuff_happens.md

It’s a good idea to increment by 10 as you create new scenes, in case you need to insert a scene between two existing ones later. To move a scene, change its number. If you have more than nine chapters, use four-digit numbers for the sequence. (If you need five-digit numbers, you should seriously consider turning that epic into a series of novels.)

Differences from MultiMarkdown


Like MultiMarkdown, Jekyll’s flavor of Markdown supports variables and transclusion. But there are a couple differences. In Jekyll, variables look like MultiMarkdown’s transclusion:

{{ page.title }}

You can draw variables from the page’s metadata, or from the _config.yml configuration file (in which case you replace page with site).

Transclusion is a function of the Liquid templating language, built into Jekyll. To include a file:

{% include.relative file.md %}

You can also use include instead of include.relative to pull files from the _includes directory. By using Liquid, you can specify parameters to do different things, effectively creating your own extensions.

For example, here’s how you might do section breaks:

<p class="sectionbrk">
  {% if include.space %}&nbsp;{% else %}&bull; &bull; &bull;{% endif %}
</p>

So if you just enter {% include secbrk.html %}, you get three bullets. To get a blank line, enter {% include secbrk.html space="true" %} instead.

Also like MultiMarkdown, Jekyll supports a metadata block at the beginning of a file. While they look very similar, Jekyll uses YAML format for its metadata. The upshot is, a Jekyll file begins and ends its metadata with a line of three or more dashes, like this:

---
title: The Sordid Tale of Woe
author: Henrietta Jekyll
permalink: /sordid/sordid_tale.html
---

Certain metadata tags are special to Jekyll. For example, permalink specifies the name and location of the HTML file Jekyll creates from the Markdown source. Another important tag, layout, can be used to choose a template. You can set the default layout in the configuration file, then use a second configuration file to override it for doing things like publishing.

Git Out


Jekyll is also a blogging tool. Your posts go into a special directory, _posts, and have a specific naming convention. Two additional metadata tags are important:

date:   2017-03-21 07:00:00 -0500
categories: writing technology

The date entry specifies the date and time your post goes live on the generated site. The categories entry lets you tag each post for easier searches.

But all that’s just pixels on the screen unless you have a place to put your site. That’s where Github Pages comes in. You can upload your Jekyll files to Github Pages, and it automatically updates your site when it finds new or changed content. This is pretty useful, but it’s even more useful when you’re working with other people. Everyone has their own copy of the source files on their own computers, and they can each push (update) their changes as needed.

Now What?


I hope I’ve given you some ideas for new ways of looking at your writing, and how to make the publishing part more efficient and more collaborative.

The rest… is up to you. I’d love to see your own ideas in the comments.

Tuesday, March 14, 2017 No comments

Tech Tuesday: Roll Your Own Writing System, part 5: Reuse

The series rolls on…

In Part 1, we had a look at Markdown and the five or six formatting symbols that cover 97% of written fiction. Part 2, showed how you can use Markdown without leaving the comfort of Scrivener. Part 3 began exploring eBook publishing using files generated from both Scrivener and directly from MultiMarkdown. Part 4 provided a brief overview to a different tool called Pandoc that can convert your output to a wider variety of formats, and is one way to create print documents for beta readers or even production.

Way back in Part 2, we used Scrivener to embed HTML separators between scenes and for internal scene breaks. As we saw last week, that doesn’t work when you need to output to a different format. As it turns out, there’s a way to work around that by using MultiMarkdown’s transclusion mechanism. Transclusion and metadata variables provide the capability for reuse, pulling common boilerplate files from a library.

Inclusion… Transclusion?


Transclusion is a technical term, but it’s easy enough to explain. You use it to embed another Markdown file into your document, like you might include a graphics file. A function like this is essential when you’re maintaining a collection of technical documents, because you can reuse common sections or passages—write them once, store them in a library of common files, and then changing one of the source documents automatically updates all the documents that use it. For fiction writing, it’s a good way to pull in all those boilerplate files (about the author, front matter, etc.) that you need for each book.

To transclude a boilerplate file, put this on its own line:

{{myfile.md}}

When you run multimarkdown, it pulls in the contents of myfile.md and processes it.

Now here’s where it gets fun. Say you really need to be able to output to both HTML and OpenOffice. Instead of embedding HTML that gets ignored in the OpenOffice conversion, or vice versa, you can use a wildcard:

{{myfile.*}}

Now, when you output to HTML, multimarkdown transcludes the file myfile.html. When you want OpenOffice, it uses myfile.fodt. You just have to supply the files with the right extensions and content, and you’re off to the races! You can use this in the Separators in Scrivener to choose the right markup for your output.

A few caveats for fodt transclusion: You cannot use entities like &bull; or &#8026; to specify special characters. You have to enter them as characters. If you only have one line to add, you don’t need to put any OpenOffice markup in the fodt file—plain text is fine, but use the right extension so multimarkdown knows which file to use.

If you want to reuse transcluded files with other documents, you can add another line to the metadata:

Transclude Base: /path/to/your/files

You can use a relative path like ../boilerplate, but it’s safer to specify the entire path in case you move the file to some other location.

Does the Front Matter?


But transcluding boilerplate files is only the beginning. Especially for front matter, you need to change at least the title for each book. Fortunately, MultiMarkdown has that covered.

In Scrivener’s Compile window, the last entry is Meta-Data. Back in Part 3, you used this to specify a CSS file for HTML output. Scrivener pre-fills entries for the Title and Author, but you can add anything else you want here. All the metadata ends up at the beginning of the file, where MultiMarkdown can process it further.

So you might have a block that looks like this:

Title: Beyond All Recognition
Subtitle: The Foobar Chronicles, Book 1
Author: Marcus Downs
Copyright: 2017
Publisher: High Press UR

Create a title page that looks like this (for HTML output):

<div style="text-align:center" markdown="1">
**[%title]**

**[%subtitle]**

by  
[%author]

Copyright [%copyright] [%author]. All rights reserved.

Published by [%publisher]
</div>

![](logo.png)

{{TOC}}

Instant front matter! The {{TOC}} construct inserts a table of contents, another Multimarkdown feature.

Now What?


Now you know how to include boilerplate files in your book, and how to automatically put the right text in each output format.

Next week… it’s something completely different to wrap up the series.

Tuesday, March 07, 2017 No comments

Tech Tuesday: Roll Your Own Writing System, part 4: MultiMarkdown and Pandoc

The series rolls on…

In Part 1, we had a look at Markdown and the five or six formatting symbols that cover 97% of written fiction. Part 2, showed how you can use Markdown without leaving the comfort of Scrivener. Part 3 began exploring eBook publishing using files generated from both Scrivener and directly from MultiMarkdown.

Today, we’re going to take a brief look at a different tool you can use to publish MultiMarkdown files.

Pandoc describes itself as a Swiss Army knife for markup languages, but it goes farther than that. More than markup languages, it converts to and from common word processor formats and can even convert directly to EPUB. You can mess with templates to get the output really close to production-ready, but that's a little beyond the scope of our series here. In real terms, it’s not any faster than loading a prepared HTML file into a skeleton EPUB; both methods need a little cleanup afterwards.

This sounds at first like it’s just an alternative to using MultiMarkdown, but it goes a little farther than that. One problem with embedding HTML in your Markdown files, none of it gets converted to other formats. So you can’t just take your MultiMarkdown file and create an OpenOffice file by running:

multimarkdown --to=odf story.md >story.fodt

Because all your section breaks disappear. Pandoc ignores embedded HTML as well… so again, what does Pandoc buy you?

Well, once you have your HTML file, you can use Pandoc to convert that HTML file to the word processor format of your choice.

pandoc -f html -t odt -o story.odt story.html

And there’s the answer to how you make your story available for beta readers who want a word processor file. If you’re willing to tolerate some sloppy typesetting, you could use it for your print document as well. Pandoc also supports docx and rtf as output formats.

Now What?


Now you can output your MultiMarkdown file in a number of formats, including eBook (direct and indirect) and common word processor formats.

Next week, we’ll look at some special features of MultiMarkdown that you might find useful.

Comments? Questions? Floor’s open!

Wednesday, March 01, 2017 No comments

Tech Tuesday: Roll Your Own Writing System, part 3: Publishing MultiMarkdown

The series rolls on…

In Part 1, we had a look at Markdown and the five or six formatting symbols that cover 97% of written fiction. Last week, we saw how you can use Markdown without leaving the comfort of Scrivener.

This week, it's time to build an eBook using MultiMarkdown output. If you have been cleaning up Scrivener’s EPUB output in Sigil, you should find the process familiar—only, without most of the cleanup part.

First thing, output an HTML file through MultiMarkdown. In Scrivener, click the Compile button and select MultiMarkdown→Web Page in the dropdown at the bottom of the screen.

Under the Overhead

Open Sigil, then import your HTML into a new eBook—or better yet, a “skeleton” eBook with all the boilerplate files already in place.

All you have to do now is to break the file into separate chapters and generate a table of contents. You can save even more time by creating a custom text and folder separator in the last part of Scrivener’s Compile Separators pane:

<hr class="sigil_split_marker"/>

Then, when you’ve imported your HTML file, just press F6 and Sigil breaks up the file for you. If you start with a skeleton EPUB file, you can have a perfectly-formatted EPUB in a matter of minutes. Seeing as it takes me an entire evening to clean spurious classes out of Scrivener’s direct EPUB output, this is a gigantic step forward.

One thing to watch out for: MultiMarkdown inserts a tag, <meta charset="utf-8"/>, at the beginning of the HTML output. EPUB validators choke on this, insisting on an older version of this definition, but all you have to do is remove the line before you split the file.

Breaking Free

Perhaps you want to slip the surly bonds of Scrivener. Maybe your computer died, and your temporary replacement does not have Scrivener—but you saved a Markdown version of the latest in your Dropbox, and your beta readers are waiting.

Scrivener has its own copy bundled inside the app, so you’ll need to download MultiMarkdown yourself. It runs from the command line, which is not as scary as it sounds. In fact, Markdown and MultiMarkdown are very well-suited to a distraction-free writing environment.

After you’ve installed MultiMarkdown, start a Terminal (or Command Line on that Microsoft thing). On OSX, press Cmd-Space to bring up Spotlight. Type term, and that should be enough for Spotlight to complete Terminal. If you prefer, you can start it directly from /Applications/Utilities.

Next, move to the right directory. For example, if your file is in Dropbox/fiction, type cd Dropbox/fiction (remember to reverse the slash on the Microsoft thing).

Here we go…

multimarkdown mybook.md >mybook.html

Now you have an HTML file that you can import into Sigil (just don’t forget to remove that pesky meta tag).

Silly CSS Tricks

Last week, I mentioned a couple of things you can do with CSS to help things along.

First, when you Compile your Scrivener project to MultiMarkdown, click Meta-Data in the options list. You should see some pre-filled options: Title, Author, and Base Header Level. Click the + above the Compile button to add a new entry. Call the entry CSS then click in the text box below and enter ../Styles/styles.css—if you’re using Sigil, it puts all stylesheets in the Styles directory. You can give it another name if you have a stylesheet pre-defined (mine is called novel.css).

Pre-define your CSS

Now open your stylesheet, or create one if you need to. Add the following entries:

p.sectionbrk {
    text-indent:0; text-align:center;
    margin-top:0.2em; margin-bottom:0.2em
}
.sectionbrk + p { text-indent: 0; }
h1 + p { text-indent: 0; }

The first entry formats the sectionbrk class to be centered, with some extra space above and below. The second one is more interesting: it cancels the text indent for the paragraph after a section break. The third entry does the same thing for a paragraph following a chapter heading (you can do this for h2 if needed as well). This is the proper typographical way to format paragraphs following headings or breaks, and you don’t have to go look for each one and do it yourself. I told you this can save a ton of time!

Again… Now What?

Now you can work with MultiMarkdown within Scrivener. You can export it, generate an eBook, and work with the file outside of Scrivener.

Next week, I’ll show you another way to make an eBook from your MultiMarkdown file.

Comments? Questions? Floor’s open!

Tuesday, February 21, 2017 No comments

Tech Tuesday: Roll Your Own Writing System, Part 2: Markdown in Scrivener

Last week, I showed you a brief introduction to Markdown. I only hinted at why you might want to use Markdown instead of comfortable old bold/italic (and other decorations). I’ll get detailed next week, but here’s a hint: you can save yourself an entire evening of work getting your eBook prepared for publication.

This week, though, we’re going to look at how Scrivener and Markdown work together. TL;DR: Very well, actually.

Scrivener supports a Markdown extension called MultiMarkdown. You don’t have to worry about the extensions, unless you’re writing more technical fiction with tables and the like. For fiction, what I showed you last week should cover all but decorative stuff.

Make a copy of your WIP. Got it open? Original one is closed? Okay, let’s get started.

In Scrivener, click the Scrivenings icon in the toolbar, then click the Draft or Manuscript icon in your Binder (whichever one your story is in). You should now see your entire story laid out in Scrivener.

Click anywhere in the story text, then go to Format menu→Convert→Bold and Italics to MultiMarkdown Syntax. If you use anything other than bold/italic in your writing—like typewriter font for text messages, or blockquotes for letters—you’ll have to go through your manuscript and mark those yourself. This is that other 10% I mentioned last week.

Stylin’

Scrivener has formatting presets, since it only remembers the formatting and not the preset name after you apply it. Not as good as styles, but they work for our purposes.

Markdown uses backticks (a/k/a accent grave) to define typewriter font: `this is a text message`. You can either insert your backticks by hand, or let Scrivener insert them when you publish. I have a preset called Typewriter for this, but we can define a new preset or redefine an existing one. Here’s how it works: any string of text marked “Preserve Formatting” (Format menu→Formatting→Preserve Formatting) gets the backtick treatment at Compile time.

So go find a text message or other small string of typewriter text in your manuscript, and select it. Apply Preserve Formatting as described above, and the text gets highlighted in cyan or light blue.

Now, go Format menu→Formatting and:

  • for a new preset: New Preset from Selection
  • to redefine a preset: Redefine Preset from Selection→(preset name)

For a new preset, enter the name in the dialog box. In both cases, select Save Character Attributes in the dropdown to create a text (as opposed to a paragraph) preset. Now, any time you mark a selection of text as Typewriter (or TextMsg, or whatever you called it), you’ll see it highlighted and in your designated typewriter font.

Looks good, gets converted to backticks. What’s not to like?

To make a block quote, put a > at the beginning of each paragraph in the block, and in any blank lines in between. Add a blank line to the end of the blockquote so the next paragraph doesn’t get picked up as well. Scrivener assumes that preserved-format paragraphs are code blocks, and displayed as-is, so you can’t use its Block Quote preset this way unless you turn off Preserve Formatting. In either case, you’ll have to add the > character.

Okay, ship it!

Not quite. There are still a few things you need to set up before you can get to the Efficiency Nirvana that Scrivener and MultiMarkdown offer.

To see where we need to go, let’s have a look at the output. In Scrivener, click Compile, then go to the Compile For: dropdown at the bottom of the compile window and select MultiMarkdown. You could also try MultiMarkdown→Web Page. Don’t forget to check which directory it’s going in, so you’ll be able to find it. Open it an a text editor (Text Edit, Notepad, whatever you like).

You should now see a few lines at the top with the story and author name, followed by the rest of the story. If you don’t use blank lines between paragraphs, your paragraphs run together in one big blob. There may not be any chapter titles, and likely no section breaks beyond blank lines. So let’s start fixing things. You’ll only have to do these once, or (at worst) once for each project.

Close the file, go back to Compile, and click Separators in the list. For Text Separator, click Custom and then enter the following:

<p class="sectionbrk">&bull; &bull; &bull;</p>

This tells Scrivener to put three bullets between each scene. (Anything Markdown or MultiMarkdown can’t do directly, you can do with HTML.) You’ll want to create or edit a CSS file to format the sectionbrk class the way you want (most people want it centered with a little space above and below). We’ll go over how to automatically link the CSS file to your HTML in a later post.

Set the other parts to Single Return. That’s all you have to do for Separators. In the other options:

  • Formatting: Check Title for Level 1 (and lower levels, if needed) folders.
  • Transformations: Check:
    • Straighten Quotes
    • Convert em-dashes
    • Convert ellipses
    • Convert multiple spaces
    • Convert to plain text: Paragraph Spacing
  • Replacements:
    • Replace (Option-Return twice); With (Option-Return)<p class="sectionbrk">&nbsp;</p>(Option-Return twice)

The Transformations section sounds a little scary, but MultiMarkdown re-converts those text entries to their nice typographical equivalents. I suggest you do it this way for more consistent results. The Replacements entry just inserts a blank section break that won’t get deleted during a conversion. You could just insert a non-breaking space, but (again) a later blog post will show you how you can use this to eliminate formatting issues.

Converting paragraph spacing to plain text replaces a paragraph break with two paragraphs, inserting a blank line between paragraphs as Markdown expects. It works if your Body paragraph format puts space at the beginning or end of the paragraph. If you use indents instead, try “Paragraph Spacing and Indents” and hope the indents are deep enough for Scrivener to catch.

If that doesn’t work, add two more entries to Replacements:

  • Replace (Option-Return); With (Option-Return twice)
  • Replace (Option-Return four times); With (Option-Return twice)

The two replacements are needed because of a bug in Scrivener. It converts one return to four instead of two, but the second time through fixes it.

Now hit Compile, then open the generated file in a text editor. You should see a plain text file, with a blank line between each paragraph and Markdown syntax for various highlighting. You can go back into Scrivener and try MultiMarkdown→Web Page to see what that looks like, too.

Now What?

Now that you can export a clean MultiMarkdown file from Scrivener, you can work with it in any text editor. Sometimes, just looking at the same text in a different way is enough to get you moving on a WIP and get it done. If you have an iPad, you can still edit your Markdown-ified project using Scrivener on iOS, or you can use an iOS Markdown editor like Byword to edit your Markdown file (and import it back into your Scrivener project later).

But that’s only scratching the surface. Next week, we’ll start looking at ways to prep your MultiMarkdown file for beta or final publishing.

Comments? Questions? Floor’s open!

Tuesday, February 14, 2017 No comments

Tech Tuesday: Roll Your Own Writing System, Part 1: Markdown

I’ve said this before, but for people who want to make a living (or even beer money) writing fiction, the best writing advice out there is still Kristen Kathryn Rusch’s: treat it like a business. Simple enough, but the ramifications are as wide as the world of commerce.
  • Watch your expenses, but don’t hesitate to spend where it’s going to improve your product.
  • Plan time for editing and marketing as well as writing (I haven’t done too well in that regard over the last year).
  • Set a budget, and track your expenses (and income) so you know if you’re meeting it.
  • Analyze your processes, and look for better ways to do things.
For someone like me, the latter can be dangerous. It’s really easy to go down a rathole, constantly tinkering with stuff instead of actually accomplishing anything. That goes double when I often have to write one-handed, with a baby in my lap who is trying to grab the keyboard or anything else within reach.

Still, I think I might have stumbled across something.
  • What if there was a way to write stories, using any computer (or tablet), anywhere you are?
  • What if you could preview your writing using a web browser?
  • What if you could output your writing in squeaky-clean HTML for producing EPUBs?
  • What if you could easily copy your entire oeuvre to a USB drive for backup or to continue writing when you’re offline?
  • And finally, what if you could play with different versions of your story to figure what what works best?
In other words, I think I might have found something better than Scrivener. That’s saying a lot; I’ve been using Scrivener for about five years now, and it’s close to ideal for the way I work. The fun part is, it’s possible to keep using Scrivener as long as you want, until you’re ready to let go.

So what is this miracle? Read on…

About Markdown

Markdown was created by John Gruber to make it easier to write blog posts. It has been extended every which way to work with more technical documents, but the vanilla version is well-suited for writing fiction as well as blog posts.

If you’ve ever decorated a text-only email, you already know how to use most of Markdown. Here’s an example that easily covers 90% of what you do in fiction writing:

# The Swamp Road

Night was falling,
yet Joe doggedly marched up the swamp road.
Time was pressing,
after all.

In the flickering light of his torch,
Joe saw two signs:

**SHORTCUT LEFT**

**Do NOT take the shortcut!**

He pondered the advice for only a second.
*Bah*, he thought,
*I have to get home*.

Taking the left fork,
Joe soon found himself sinking in the bog.

Let’s see how this looks when formatted:

The Swamp Road

Night was falling, yet Joe doggedly marched up the swamp road. Time was pressing, after all.
In the flickering light of his torch, Joe saw two signs:
SHORTCUT LEFT
Do NOT take the shortcut!
He pondered the advice for only a second. Bah, he thought, I have to get home.
Taking the left fork, Joe soon found himself sinking in the bog.
It’s pretty easy to see how this translates: blank lines start a new paragraph. Use asterisks to highlight, *for italic* and **for bold**. The number of pound (or hash) characters set the heading level. For example, # Heading 1, ## Heading 2, and so on.

In the example above, I broke lines inside each paragraph so each line is a phrase. That’s not necessary; you can go long and run your paragraphs together, like you would in Scrivener or a word processor. Either way, you’ll get properly-formatted paragraphs.

But I LIKE Scrivener!

Hey, no problem. Scrivener has built-in Markdown support, and can use it to produce cleaner output for publishing than its direct word processor or eBook output. We’ll have a look at how to set things up, and a couple of things to look out for, next week.


Thoughts? Questions? Floor’s open!

Thursday, February 09, 2017 No comments

Tech Tuesday (on Thursday): Tines 1.11

I didn't get this posted Tuesday. Oh well.

The two biggest components in this release are compatibility enhancements:

  • Tines now compiles and runs on Cygwin, something I've wanted for a while. That involved changing escdelay from a variable to a CLI command. The change is backward-compatible; there’s no difference in how it works in .tinesrc and scripts.
  • Tines now preserves and (where it makes sense) uses the metadata in the OPML <head>. You can access and change metadata through text variables, and Tines uses reasonable defaults when necessary.

With 1.11.0, Tines is essentially complete. The Creeping Feature Creature will get hungry some day, no doubt, but for now I’m going to focus on making packages available for people who don’t want to compile the app themselves, making the code more robust, and squashing any bugs that turn up. I might tinker with alternative RC files to focus Tines on special purpose uses as well.

Tuesday, August 30, 2016 No comments

Tech Tuesday: Distraction-Free for Free

I’m a very technical boy. So I decided to get as crude
as possible. These days, though, you have to be pretty
technical before you can even aspire to crudeness.
— William Gibson, Johnny Mnemonic

The writing advice people (and websites) are always harping about minimizing distractions. Shut off Twitter (or your social media of choice), close the browser, fill your screen with the editor, and just write look a squirrel! You can even buy special editors that fill the screen automatically… well, of course you can. Seems like everybody and their dogs are trying to make money off writers these days, aspiring and otherwise.

The thing is, it’s really easy to set up a distraction-free writing environment using the tools and apps that come standard with your operating system—at least for MacOSX and Linux. It’s probably true for the Microsoft thing as well, but I’ll have to look at it a little closer. Both MacOSX and Linux evolved from Unix, an operating system that dates back to when computers were more expensive than displays—so you would have a bunch of people using one computer, typing commands and text into terminals. That was back when timesharing didn’t refer to a sketchy way to sell the same condo to 50 people.

The interesting part is, all the code needed to support that circa-1980 hardware is still part of modern operating systems, and we can use that code to create our distraction-free environment. So let’s get to a shell prompt, the way we all interacted with computers before 1984.

Down and Dirty

If I really wanted to get down and dirty, I’d get a USB-to-serial adapter and hook up that old VT220 terminal I still have laying around. But we’re focusing on stuff you already have on your computer.

Personally, I like to have some music playing while I’m writing at home—it masks TV noise, kid noise, dog noise (unless there’s a thunderstorm, then she’s moaning under my feet), and noise from outside. But you might have a stereo in your writing room, or you find the music distracting, and you don’t need anything but a screen to type into.

Keeping the Johnny Mnemonic quote above in mind, Linux is more technical than MacOSX, so it’s easier to get to the crudeness you want using Linux. Press Ctrl+Opt+F1, and you’ll be presented with a glorious console with a login prompt. Most versions of Linux have six of these consoles; press Ctrl+Opt+F7 to get back to the graphical interface. I have never dug into the reason why Linux typically has six text consoles… I’m sure there’s a reason. Anyway, enter your usual login name and password at the prompts.

If you’ve set up MacOSX to automatically log you in when you start up… don’t. For one thing, you’re inviting anyone who gets into your house to poke through your stuff. For another, you can’t get to the one console that Apple provides. To fix this, open System Preferences, select “Users and Groups,” then click “Login Options” at the bottom of your list of user names.


Once you’re there, make sure “Automatic login” is set to Off. Next up, set “Display login window as” to “Name and password.”

While you’re in this screen, make sure your regular user name is not an administrative account. Set up a separate admin account if you need to, and remember that admin password. These are things that make it harder for malware (or your teenage niece) to do things they shouldn’t be doing on your computer.

But I digress. Next time you log in, instead of typing your usual user name, type >console and press Return. This immediately drops you into a text console and presents you with a login and password prompt.

So… Linux or Mac, you have a text console until you press Ctrl+D at a shell prompt to exit. Skip down to “Now What?” to see what’s next.

Work Within the System

If you’re not quite ready to abandon all hope the graphical interface entirely, because you might need to jump onto the Web to goof off research something important, you can still eliminate most distractions… although all those distractions are still easily available if you can’t resist. Perhaps it’s a small price to pay to have your music, right?

Most Linux systems make it really easy to get a terminal app on the screen, whether through shortcuts or the application menu (look in Accessories or Utilities). Macs aren’t much more difficult—press Cmd-space to pop up Spotlight; typing term should be enough for it to complete Terminal (it’s in /Applications/Utilities if you want to do it from the Finder). Press Return, and it should start. If you’re using the Microsoft thing, look for “Command Prompt” or “PowerShell” in your Start menu. One or the other should be in Accessories.

Now that you have a terminal window up, you need to maximize it to keep the distractions at bay look a squirrel!. On Macs, press Ctrl-Cmd-F to enter full-screen mode (press it again to exit). On Linux, your distribution determines the keystroke; Ubuntu uses F11. You can always click the “maximize” button to expand the window, although this leaves extraneous window elements visible. You can also maximize a command window in the Microsoft thing.

One of the advantages of a terminal app over a console: you can increase the text size, either by using the terminal app’s preferences or by using a keystroke (Cmd+ on Macs). 18 points should be sufficient on a laptop; you might want 24 points or even huger on a big desktop screen.

Okay, you’re ready to go…

Now What?

Okay, now you have a screen full of nothing but white text on a black background. There’s a prompt at the top, usually ending with a $ symbol.

The distraction-free writing paradigm basically turns your computer into an electronic version of a manual typewriter. No going back, no editing on the fly, just type your story and hope the result isn’t too incoherent to salvage (says the guy who likes to edit as he composes).

There are few lower-level ways to input text than using a line editor, and Unix derivatives (including both Linux and MacOSX) include ed.  Johnny Mnemonic, that technical boy, would have been proud of ed. It’s about as crude as it gets. So let’s get crude! Type ed and press Return.

Nothing happened. Or did it?

Ed (as we’ll refer to ed for a while) is a program of very few words, which is exactly what you want when you’re going for a minimalist writing environment. If you give Ed a command he doesn’t understand, or one that might destroy your work, he will respond with ? (a minimalist understands when that means “huh?” or “you don’t really want to do that, right?”). Ed’s commands all consist of a single character; in some cases, you might include a range of lines or some other info. But right now, there are three commands you really care about.

Right now, you should see a blank line. Type i and press Return. This enters input mode, where everything you type is copied into Ed’s buffer. Ed will happily ingest everything you type, until you enter a line containing only a . character. That tells him to return to command mode. The following screen shot shows an example.


Now for the second command: saving what you entered. Type w and the name you want to give the story. Make sure you’re not using that name already, or you’ll overwrite what’s there! I reserve a few file names like foo, junk, and tmp for situations like this, when I either don’t need to keep what’s in the file or plan to do something else with it right away (like copy it into Scrivener). Anyway, after you use the w command, Ed responds with the number of characters it wrote into the file. If you want a rough word count, divide by 5 (I wrote 1458 characters, a shade under 300 words, in the above example).

All done! Type q and press Return, and you’ll return to the shell prompt. If you want to keep writing instead, type $a and press Return. This command means “go to the last line” ($) “and append.” Again, Ed will take everything you type as input until you enter a line containing only a . character. This time, you can just type w and press Return, because Ed remembers the last file name you used. Just remember to use q when you’re done.

Bonus Info

Now you’re at the shell prompt, and you want to know exactly how many words you typed? Type wc and the file name, and press Return. The info you get looks like this (using the above example):

Kahuna:fiction larry$ wc tollen.md 
      31     269    1458 tollen.md
Kahuna:fiction larry$

You get three numbers: lines, words, and characters. So that number in the middle, 269, is the actual number of words I wrote.

If you’re not enamored with Ed’s ultra-minimalism, try entering nano or pico instead. Both of these are simple screen-oriented text editors that include a little help at the bottom of the screen (but will let you arrow back and noodle with the text).

Like with any writing tool, you’ll improve with practice. Don’t give up right away; try a different editor or even a different color scheme (most terminal apps let you choose colors). And don’t forget to copy your text into your normal writing tool!

Your Turn!

Have you ever tried a minimalist writing environment? How did it work? Get as detailed (or as minimalist) as you like in the comments.

Tuesday, August 02, 2016 No comments

Tech Tuesday: Getting Your Outline into Scrivener (pt 2)

In last week’s post, we saw how you can import an OPML outline directly into Scrivener. For those of us who use an outliner for more than the barest-bones plotting, it’s rather limiting. Fortunately, Scrivener has another way to import. It requires an extra step, but Tines (the console-mode outliner I use and maintain) can do the work.

So let’s go…

No Extensions Required

OPML entries have a type attribute associated with them. The standard deliberately leaves the content of type undefined, except it’s some kind of text to describe the entry.

Tines supports two type definitions: "todo," to give an entry a checkbox, and "text" to mark entries as content (non-text entries are assumed to be headings). Tines assigns the F3 key to toggle between text and heading types. A lowercase t to the left of the bullet gives a visual indication. So now, let’s add some more info to the first scene:

Nothing like a little slapstick to start a story, huh?
Note the t at the beginning of each entry under Scene 1. Those are text entries. Other entries will become documents in Scrivener.

Now here’s where the magic happens. In Tines 1.10, there’s an Export->XSLT function that allows exporting through xsltproc. Since OPML and Tines’s native hnb format are XML files, it’s easy to convert them to just about anything. Press ESC to bring up the menu, and go to the File menu…

Changes to the look and feel are due to experiments with the configuration.

Scroll down to Export->XSLT, press Return, then press M at the next prompt to choose Markdown. When prompted, enter a name for the Markdown file (I used storymap.md). If you want, have a look at the Markdown file to see how it does things—a # character at the beginning of a line is a heading, and the number of # characters says what level heading it is. Other lines are body text. Easy, huh?

Now let’s load it into Scrivener. There’s two ways to do that.

Import and Split

I don’t really recommend using File→Import→Import and Split. It works as advertised, importing your Markdown file and splitting it up, but it doesn’t build a hierarchy. It might be useful for importing an outlined chapter into an existing project.


Import as MultiMarkdown

MultiMarkdown is, as one might guess, an extended version of Markdown. Since it’s an extension, you can import plain Markdown as MultiMarkdown without a problem. So try File→Import→MultiMarkdown File instead. Here’s how it looks:


Now this looks pretty close to what we want! Everything is in a nice hierarchy, content is content, and we’re ready to get the story knocked out.

Until next time… keep writing, and keep geeking!

Tuesday, July 26, 2016 No comments

Tech Tuesday: Getting Your Outline into Scrivener (pt 1)

Part 1 of a two-part series

I’m a pantser by nature. I like to get the story started, then let the characters tell me what happens. But that doesn’t always work. Sometimes, in the heat of composition, you get ideas for side-stories, sequels, and completely different worlds. You can sometimes placate the plot bunnies by giving them a little attention, taking down a few notes and promising to come back when the story at hand is done. Of course, an outliner is one of the best ways to organize notes and plot a story—in the 8-bit pre-DOS days, an early vendor was pleased to call their offering an “idea processor” (and an outfit called Axon uses that label for their mind-mapping tool today).

Scrivener’s Binder pane can be used as a crude outliner. But when you’re trying to bang down some ideas before you forget them (or get distracted by a family member), you want the speed and smooth operation that you get from a dedicated outliner or mind-mapping tool1.

Fortunately, most outliners and mind-mappers support OPML (Outline Processor Markup Language), a very simple XML document type—and so does Scrivener, at least for import. So you can knock out your outline in your favorite outliner or mind-mapper, export as OPML, and pull it right into a new Scrivener project with the hierarchy in place.

Tweaking Scrivener

Before you import, though, you should review Scrivener’s OPML Import settings to make sure they’ll work the way you want. Open Scrivener’s preferences and follow the red numbers:

There’s not much to change. Creating a folder is needed only if you’re importing notes rather than your story line. If you have a “root” entry, with everything else as a lower-level entry, then you already get what amounts to a new folder.

Dealing with notes may or may not be an issue for you. The commercial OmniOutliner added a “note” extension to OPML, for reasons unknown to me, and other outliners (including Tines) now include at least token support for it. Creating a note, and telling Scrivener to import them into the main text of each document, is the only way to pull in content (other than chapter and scene names) using OPML import. Other options are to put notes only in the synopsis, or add them to document notes.

Pulling It In

Maybe an example would help. Thus, a generic story called The Importing, a slightly filled in outline (Trevor McPherson’s StoryMap for Freemind, converted to OPML for this job). I added a note to the first scene in Tines, using an experimental OPML-centric configuration file:


The note content is at the bottom of the screen. Internally, notes use a _note attribute, in parallel with the entry text. Imported into Scrivener, we get something that looks like this:


As you can see, every entry in the outline becomes a document. Notes are extremely limited for writers who want to put in more than one line of content in a scene. I don’t know about anyone else, but I often want to add bits of dialogue, maybe some descriptions of the setting, who’s making an appearance, how the scene wraps up… you get the idea.

Fortunately, there’s another way to get your outline into Scrivener, one that lets you include all the content you feel like adding in the outliner. We’ll take a look in Part 2.


1Think of a mind-mapping tool as a graphical version of an outliner. Each entry is a bubble, centered around a root entry, and can be arranged to suit your needs. Freemind is an open-source example, and runs on all platforms (needs Java though).

Tuesday, June 07, 2016 3 comments

Tines 1.10 (Tech Tuesday)

Friday night, after a few rounds of testing, I decided Tines 1.10 was ready to go and uploaded the source code.

Tines is primarily an outliner, but has functions that make it useful as a planner, organizer, and notebook as well. The code is based on hnb (Hierarchical NoteBook), which I used quite a bit 10 years ago. It runs in a console (terminal, shell, what-have-you)—so it’s plain-text all the way. It can be customized every which way by editing a configuration file, so you can pretty much have everything but a graphical interface. :-) I kept trying different outliners, and kept coming back to hnb because I could make it work exactly the way I wanted.

I mostly lost track of hnb 8 or 9 years ago, after getting a new MacBook Pro at work. The Pro came with OmniOutliner, a very popular MacOS outliner, and I started using it. Then when I got pushed onto a Dozebox, I didn’t have a decent outliner and basically gave up. But late last year, I started looking for a decent outliner to use for both work and personal writing projects. Given that there’s a well-known interchange format for outliners, OPML, having the exact same outliner on all three platforms isn’t a necessity. But I remembered hnb and decided to give it another try.

Technology moves on, and hnb compiled okay, but crashed immediately when starting. I hadn't messed with C code much in years, but it came back to me quick enough. Looking at the source code, I realized it was using 32-bit integers for pointers and modern computers use 64-bit pointers. After fixing all those, it had it running again. I posted to the mailing list on SourceForge and offered patches. One correspondent pointed out that mine was the first legitimate post on the mailing list in years, and suggested I just fork the code and take it over. As if I wasn’t crazy-piled with projects already… but I did it. Thus was Tines born. And Charlie moved into FAR Manor not three weeks later.

Enough of that… what’s it like?

The screen shot here should give you a pretty good idea what Tines looks like. It uses color where available, so it’s not completely boring. It doesn’t use the mouse (yet), but it has menus, function keys, and highlighting.

If you don’t specify a file, Tines opens its “default database” (specifically, .tines in your home directory on OSX and Linux). This is handy for brainstorming stuff, keeping notes and other useful tidbits, or using Tines as a planner. It can import OPML files, save all or part of an outline as OPML, and works with several other file formats. But you can open hnb files (the native format), OPML files, and tab-indented plaintext files as well.

You can use the arrow keys to move around, and use keyboard shortcuts (or press ESC to open the menus) to make changes.

The Planner menu helps you set up a planner, according to David Allen’s Getting Things Done methodology. One powerful new feature in v1.10 is the today command (mapped to “Today’s Agenda” in the Planner menu). If you have set up a calendar using the Planner menu, this command jumps to the entry for today’s date and displays all the items under it. This lets you computerize your tickler file, at least for to-do items and other things that don’t require paper.

If you have a large outline, and you probably will if you keep everything in the default database, you can search for buried treasure… I mean, items that you can’t quite remember where they are. The Level menu lets you sort items in a particular level, which might be useful for notes. There’s also a “shuffle” mode, to randomly disorder items in a level. I’m not sure why you would want to use that, except it might help you to discover relationships between items, but it’s there if you need it.

All well and good—how do you use it for writing?

I’ve long been a pantser, but as I continue writing I find I like to loosely plot my projects so I don’t forget things. Plotting isn’t as fun as letting things happen, but it’s a lot less scary when you have people asking you when the next book is on the way. (And for those of you who have been patiently waiting for The Blood of Heroes, the first draft is almost done. Finally.)

But I digress. An outliner is a good way to plot out a novel or a work of non-fiction. Instead of stifling creativity, it lets you think about other creative things by capturing your thoughts about how to organize your work. I have a memory like a steel sieve, and it frankly scares the crap out of me when I depend on remembering details of the Accidental Sorcerers series—about 200,000 words total published, and more coming. The amazing thing is, I haven’t forgotten anything crucial… so far. But Tines is more than an outliner, and that means you can use it for both your outlines and your story bible without switching applications or even files.

Now here’s the fun part: you can export all or part of your database as OPML. Scrivener reads OPML files, and can create chapter folders and scene documents for each entry. It recognizes the _note attribute extension, and can (by your preference) insert those notes into either the Synopsis or the document proper. So you can add the following code to your .tinesrc (default configuration) file to edit notes:

bind ^N "macro edit_note"
macro define edit_note
 att_get _note
 getquery "Replace _note with:"
 att_set _note $query
end

Press Ctrl-N to create or edit a note. That will end up in the next release, v1.10.1, before too long.

Where do you get it, and what’s next?

Next, I plan to create packages for MacOS X and Linux. Then, I want to get it ported to MS-DOS or FreeDOS and create packages there as well.

Right now, you have to download and compile1 Tines. That certainly limits its extent, even more so than it not being readily available on Doze right now, but that too is on the list. Please give it a try, if you’re inclined, and let me know how it works!


1Compile: from the Latin “com” (together), and pile (a random heap, or possibly hemorrhoids). Thus, “compile” means either “throw things together in a random heap” or “a multifaceted pain in the ass.”

Do you use an outliner? How? Sound off in the comments!

Tuesday, May 10, 2016 5 comments

Protect Yourself from Ransomware (Tech Tuesday)

Welcome to Tech Tuesday, my new occasional column covering the nuts and bolts of writing, publishing, and keeping your tools sharp. There’s likely to be what my redoubtable co-op partner Angela Kulig calls “Finnish,” but I’ll try to keep it accessible.



You’re working away one evening, when your computer locks up and shows you something like this:

Bad news. Really bad news.
Image source: fbi.gov

Unfortunately, it’s not the plot of a bad cyberpunk novel. It recently happened to an acquaintance. Last year, I wrote about Three Ways to Crash-Proof Your Writing, and the tips are still useful. But you might need a little more caution when it comes to ransomware.

What’s Happening In There?
In short, a PC infested with ransomware establishes a connection with its operator. The PC might run normally for a while after getting infested, but at some point the ransomware begins encrypting data files with common extensions like .doc, .psd, .jpg, .zip, and so forth. When it’s done, it displays a ransom note like the one shown above. Operators usually demand Bitcoin payments, because they can’t be traced. Some ransomware allows you to decrypt a single file, thus proving they have the key, and usually give you a few days to get the Bitcoin you need to pay up. If you wait too long, the ransom goes up or the operator destroys the key (which means you're permanently hosed). Scary crap.

Unfortunately, Dropbox is not a failsafe. Ransomware encrypts everything on your hard drive, and if you have Dropbox mirrored, it nails your files there as well.

George R. R. Martin famously does his writing on an air-gapped (i.e. no network connection) PC, running WordStar on MS-DOG [sic]. While he uses WordStar for its simplicity, he also has little to fear from most stripes of malware. Such a setup works well in the traditional publishing realm, where they still prefer to start from paper drafts, but it’s not a bad idea for indies. One might balk at the expense of a second computer—but the typical ransom these days is $500, and you can get a netbook for half that. It’s not bad insurance. Remember, if you’re trying to make money at writing, this is a business. Ransomware is one more disaster to plan for.

Let’s assume that, because you have no room or money for an air-gapped computer, or need to have a browser handy for research, that’s out of the question. What else can you do? Read on…

GROW
Right now (May 2016), the most effective way to avoid ransomware is to GROW (Get Rid Of Windows). Move to MacOS, Linux, or OpenBSD if you possibly can. This is likely a temporary advantage, but it may be a couple of years before ransomware goes beyond Windows. And if the techie press breathlessly reports every minor instance of MacOS malware found in the wild, they’ll be so beside themselves over MacOS ransomware that we’ll never hear the end of it. In other words, it won’t sneak up on us. Actually, I expect iOS malware first, because iDevices are so popular.

As a possible workaround, install a virtualization tool such as VirtualBox, VMware, or Parallels and run a separate operating system inside the virtualizer for Internet access. This isn’t foolproof—ransomware can encrypt virtual drives at a stroke, if you make a mistake—but it’s a little safer.

Stay Up to Date
That should go without saying, but it’s so easy to skip those updates in the middle of a project. Sometimes, there’s good reason for that; updates have been known to hose a working PC. If you’re doing your backups, though, you should be able to revert when needed. Don’t forget to check the backups, on occasion, to make sure important data is still good.

Don’t let your virus/malware protection slide, either. Keep them updated.

Avoid Common Attack Vectors
Currently, there are several common, well-known ways malware (including ransomware) can infest your system:
  • Dodgy attachments in spam
  • Compromised ad servers
  • Websites with infectious Javascript or Flash
Thus, installing ad-blockers and Flash blockers in your browser(s) can offer protection from so-called “drive-by” attacks. Turning off Javascript, once a common trick to speed up browsing and stop useless visual effects, is making a comeback as well. Try it with your favorite websites and see if you can live without it. You can certainly live without it trying to download garbage onto your computer.

Spammers will never go away, even if there’s a special place in Hell for them. They are paying more attention to grammar these days, so you can’t always catch them out by stilted language anymore. Some spam is really phishing, attempting to get you to click a link or open an attachment that Does Not End Well For You. If you’re not expecting that payroll statement from someone you’ve never heard of, don’t open it. If your bank sends you a report about fraudulent activity about your account… it’s not really your bank. A real bank fraud department will call you, verify your identity, then go over a few transactions. (I’ve been there.) In short, don’t open attachments you aren’t expecting.

Pull a Dirty Trick
Since ransomware only encrypts files with known extensions, consider renaming crucial backup files. Instead of GreatAmericanNovel.zip, rename it with a random extension like GreatAmericanNovel.e7b. If you have a thousand photos you don’t want to lose, copy them somewhere else now. Anything your computer can’t access directly, as if it’s on your hard drive, is safe. To be honest, I’m not sure how Google Drive works with saving local copies on a computer; I do know you have to start the Drive app to get the latest onto a tablet or phone, though.

In short, the goal is keeping your computer clean. Failing that, you want to recover with as little hassle as possible. Anticipate the disaster, have a plan, and execute.

References
If you want to dig a little deeper, here’s a couple of links that might be useful:

Your Turn
Have you been clobbered by ransomware? Do you have some prevention or recovery tips? The comment section is open.

Wednesday, March 04, 2015 4 comments

Writing Wibbles: Is B&N Flirting with Vanity Publishing? Yes. (UPDATED)

We—that is, those of us at Green Envy Press—are making the push into print this year. This came about a year after what I had planned, but we’ll have some very nice-looking books indeed. Since most of our eBook income is from Amazon, using Amazon’s CreateSpace service was the first and obvious choice. But being an indie author is about anything but the obvious choice, so we started poking around. I remembered hearing that B&N’s Nook Press had set up a print on demand (PoD) service, and I thought, “hey, that’s a no-brainer… maybe people can order books in the store for pickup.”

Well… no. In their own words:


Well, crud. Seems like they’re missing out on a really good opportunity to skewer Amazon here. Amazon can’t say “hey, order this book and have it shipped for free to your nearest brick-and-mortar for pickup… and while you’re there, check out the thousands of titles” etc. And while Amazon can’t, B&N simply won’t.

Okay, maybe there’s some stuff happening behind the scenes, something beyond the usual hidebound “we ain’t never done that way before” you see in lots of old-guard businesses. Maybe their suppliers (aka big publishers) are leaning on them to stifle competition, they way they tried (and failed) with Amazon. Or maybe they consider it too big of an expense or something… who knows? If they wanted to limit this to “serious” authors, they could easily require an ISBN.

But I got an email from B&N recently that, in combination with the above, got my alarm bells ringing. I guess it wasn’t enough to have a PoD service that they won’t help you sell, now they have author services as well:


Now those prices are in line with what I’ve seen from freelancers, but the whole thing smacks of a vanity publishing setup, especially if you scroll down to see their “packages.”

I emailed B&N to ask them about these issues; their auto-responder said “we’ll get back to you in 24 to 48 hours,” and that was a week ago Tuesday. If they do respond, I’ll update this post.

UPDATE: OMG. B&N still hasn’t responded, but Katherine Hajer pointed me to an article at Nate Hoffelder’s Ink, Bits, & Pixels. It’s worse. Much worse. They’re using the well-known scam factory Author Solutions, and trying to hide it. No wonder they ignored my request for info.

Other reading at:
David Gaughran’s Let’s Get Digital
The Passive Voice

So… thanks, but no thanks. We’ll stick with CreateSpace for now to test the waters, and maybe move to Lightning Source or another printer later if the sales warrant it.

Everything from here on out is speculation and opinion from yours truly, so adjust your filters accordingly:

Amazon may not have created indie publishing, but (like Apple with computers) they made it work for a lot of people. And yes, CreateSpace offers author services, but they also provide you with a marketplace to sell your books. I guess the point is, Amazon is trying to make money with indies, while B&N and vanity presses try to make money from indies. One treats you as a partner (however junior), and the other as an income source. I hasten to point out that there are plenty companies with a similar outlook to Amazon’s (Smashwords being one of the most obvious), but there’s one company that most of us think of first, at least in the Western Hemisphere.

Too bad, B&N. You coulda been a contender. Your brick and mortar stores give you an advantage that Amazon (or even Apple, who isn’t likely to start selling fiction in their stores any time soon) can’t easily match. You just needed the will to buck the system, instead of crawling into bed with the scummiest of scammers. You could have built a solid business with indies, but instead you treat us as marks to suck dry.

Wednesday, October 15, 2014 3 comments

Writing Wibbles

I always feel like
somebody's watching me
(And I have no privacy)
—Rockwell

I had a couple of things to share this week—an interview with the creator of the #amwriting hashtag was at the top of the list—but something else reared its ugly adobe head, and vaulted to the top of the list.

Nate Hoffeider at The Digital Reader broke the story a little over a week ago. Adobe Digital Editions (ADE) version 4 “[seems] to be sending an awful lot of data to Adobe’s servers.” Most EPUB-based eBook readers on the market use some version of ADE, although I’m not sure whether any are using ADE4 just yet. Older versions are less intrusive.

How intrusive is this? Let me quote Mr. Hoffeider here:
Adobe is gathering data on the ebooks that have been opened, which pages were read, and in what order. All of this data, including the title, publisher, and other metadata for the book is being sent to Adobe’s server in clear text. …

Adobe isn’t just tracking what users are doing in DE4; this app was also scanning my computer, gathering the metadata from all of the ebooks sitting on my hard disk, and uploading that data to Adobe’s servers. …

And just to be clear, this includes not just ebooks I opened in DE4, but also ebooks I store in calibre and every Epub ebook I happen to have sitting on my hard disk.
(emphasis mine)

The Passive Guy, a lawyer who writes on self-publishing issues, has an excellent summary and links, both in the article and from readers in the comments.

Much of the outrage in the tech side of the community focuses on Adobe’s use of plain text. That is a little disturbing, yes—it means anyone who can put a packet sniffer anywhere along the path between you and Adobe can see all this data. But for me, it’s what the people owning the servers are doing that’s more important. Scraping your hard drive for eBooks makes ADE4 spyware, in my opinion.

When pressed for an explanation, Adobe finally said (in the typical corporate lawyer speak of any company caught with their hands in your pockets) that it’s part of their DRM, and they gave themselves permission to do it through their “privacy” policy.

Now I can already hear the Kindle haters shouting “Amazon does it, too!” Well, yes, Amazon does send some information back to the mothership, but there are (as I see it) three important differences:

  1. Amazon is pretty up-front about what their Whispersync feature does, and it gives back by letting you sync your books across devices. Adobe gives you nothing (or maybe they use the info to target advertising at you, who knows?). You can also turn it off at any time.
  2. Whispersync isn’t a DRM mechanism, at least primarily. It works just as well with non-DRM books sold through the Kindle store.
  3. Amazon doesn’t presume to scrape your hard drive, looking for any MOBI or AZW files you might happen to have, just because they feel like it.

To Panic or not to Panic (probably not)


Since I handle all eBook formatting for Green Envy Press, and I work in EPUB format, I’m pretty sensitive to the idea of some corporation scraping my hard drive and looking over works in progress. Fortunately, I don’t use Adobe software in any part of my production toolchain.

But this is the problem: if people with access (legal or otherwise) to Adobe’s servers were to target a publisher’s typesetting department, they could get advance notice of upcoming titles or other intelligence. Or they could target individuals for blackmail purposes. I find it quite likely that Adobe’s legal department will use this info to shake down unfortunates who land in some kind of piracy profile (whether they’re actually pirating eBooks or not)—or sell the info to large publishers, so they can do the shaking down. I also expect Adobe to “share collected information with our third-party partners” (i.e. sell information about your reading habits to anyone who wants to spam you to death).

On the other hand, this affects only a small but growing number of individuals—those who have been suckered into installing ADE4 on their computers. I don’t know whether any eBook readers use ADE4, or will load that Trojan Horse in a near-future update. Obviously, people in the Kindle ecosystem are immune (beyond the Whispersync issues I mentioned earlier). Apple’s iBooks ecosystem is also Adobe-free, or so I’ve read. Earlier versions of ADE are not nearly as intrusive, so you’re safe in that case as well.

Fortunately, and I’ve said this before, eBook DRM is ridiculously easy to disable. Buy your eBooks from any authorized retailer, strip the DRM, and use Calibre or a third-party eReader to read on your computer. Or buy from those of us who make sure the “use DRM” selection is turned off when we publish.

And then, there’s the technical fix: block the IP addresses assigned to Adobe’s servers at your router. Whether you use DSL, cable, or fiber to get your Internet fix, your router has a fairly simple way to set this up. Look for something like “outgoing filters” and add the addresses shown in the image below. Here’s what I’ve added to my DSL router, just in case:


That won’t stop ADE4 from getting all chatty if you take your laptop outside the house, but it’s a start.



If you haven’t tried my eBooks—DRM-free, available for both Kindle and the rest of the world, and priced to move—why not check them out? The Crossover is free, and the rest are cheaper than a large latte. And unlike a latte, you can enjoy them again and again.

Tuesday, April 16, 2013 3 comments

Sideloading EPUBs into iBooks

Sideloading: the process of transferring data between two local devices, in particular between a computer and a mobile device [such as an eReader].
— Wikipedia

While a backlit LCD isn’t the best kind of screen for reading eBooks, Apple does make the experience as pleasant as possible with its iBooks app. On an iPhone, it hyphenates long words, to avoid making the margins too horrible. While Stanza is growing ever more outdated, there’s still a need to load EPUBs into a reader, just to make sure they’re right if nothing else. And sometimes, you might buy an eBook from Smashwords that you still want to read on your iOS device.

Fortunately, the process is straightforward.

1. Find your eBook.
When you download an eBook, whether on MacOS or that Microsoft thing, it usually ends up in your Downloads folder. Leave the folder window open on your desktop.



2. Open iTunes.
If you’re like me, you already have iTunes open in the “mini player” view. You need to open the expanded view. If you’re using the latest version, display the sidebar and look for “Books.” Select it to see the books in your library.



3. Drag and drop.
Arrange your Downloads window, and the iTunes window, so you can see them both. Drag your book file into a blank area of the iBooks window. It may take a few seconds for the new book to show up in your library, be patient.



4. Sync and go.
Plug your device in and let it sync. It will automatically copy your new eBooks over.

You can actually do the first three steps in less time than it takes to read this blog post… although the sync process will take a while longer.

Wednesday, March 06, 2013 4 comments

Writing Wibbles

Between the day job and the family, sometimes I have to snatch writing time when and where I can find it. I’ve done plenty of handwriting onto notepads and journals, but then I have to type it all up again. Sometimes, it’s the right thing to do. Sometimes, it just feels like a hassle.

Technology is a wonderful thing (as long as the batteries hold up, of course). If there was a way to have something about as portable as a writing journal, but doesn’t force you to write it twice, why not use it?


Behold, it really does exist!

The required ingredients are a smartphone, a Bluetooth keyboard, and +Evernote. I have to take off my glasses to read, so they make a fine phone stand. As you can see, the A key on the keyboard has gone to the Great Computer Room in the Sky, but it only took a little adjusting on my part. All of the components here can be substituted—use a tablet instead of a phone, use whatever Bluetooth keyboard will pair with it, use Dropbox or Google Docs instead of Evernote. The whole point is to have something you can type into, then copy/paste from Evernote into your normal writing tool.

This rig does get some attention when I’m at lunch. People come by to see what I’m typing into, or just what it is I’m doing. They want to know how it works, and sometimes what I’m writing.

Sunday, December 23, 2012 3 comments

Changin', Arrangin'

The wife asked me to clean off the computer desk in Mason’s room, because she wants to move her video editing system in there. Then the old office will become a guest bedroom. So in I went, with trash bags, vacuum cleaner, and a rag with a can of Pledge. The dust bunnies were large under there, but not overly aggressive. I think I bagged about a pound of them, along with a half-ton of trash and a new (and unused) power strip.

With that done, I hung the DSL box on the wall next to the router, and neatened up the UPS position. Then it was time to unhook everything in the office and drag the computer stuff over. That went as well as could be expected, dusting each item as I brought it in. There are plenty of dust bunnies in that room, too, but the pile of papers on that desk is close to approaching critical mass and creating a black hole like the one we had in our college dorm room. She knows what the papers are for, so I’ll let her deal with them. :-)

So after I got Mason down for a nap, and the girlies took off, I finally got to relax. Then I got a text from Daughter Dearest: Go ahead and clean off your desk, so we can move the one upstairs downstairs. So there were more oversized dust bunnies, more trash, and then I hauled the old desk into the living room. With that space open, I cleaned out behind the dresser before moving the new desk into position.

Then… I started loading it up. The new desk has both more and less space, both due to the shelf. The laptop and monitor couldn't both be up there, so I moved it as shown here. But there’s room for the microphone, and (with a little more arranging and dust bunny eradication) I managed to get the laser printer in place. The printer was displaced by the wife’s DV deck.

I got smart and zip-tied the power strip to the framework on the back of the desk—now, it’s out of the way but reachable. The UPS is on the bottom shelf, and the desk is on rollers, so cleaning behind it won’t be an ordeal. Maybe the dust bunnies won’t have a chance to proliferate this time.

LinkWithin

Related Posts Plugin for WordPress, Blogger...