Thursday, November 9, 2017

Correcting An Omission In a Previous Post


On November 1, I put up a post about best practices for using MadCap Flare. The post included some tips from Craig Wright of StrayGoat Writing Services , but I didn't include his contact information. Sorry about that.

Craig's web site is https://straygoat.co.uk/.

Thanks, Craig.

Wednesday, November 8, 2017

Creating Image Maps in Flare


I was asked on LinkedIn whether Flare supported image maps and how to create them. I don't see image maps used much anymore but they can be useful. Flare makes it easy to create them with its built-in image map editor. Here's how:
  1. Insert your graphic in the topic.
  2. Right-click on the graphic and select Image Map from the dropdown menu.
  3. Click on any of the three "New... Mode" buttons on the toolbar and draw the desired shape. To resize a shape, click on and drag one of its drag handles. To move a shape, just drag it. There are various other image options, but the three mode buttons are the core.
  4. After you create the shape, double-click it. The Area Properties dialog box opens. (It's basically the same as the Hyperlink Properties dialog box.)
  5. Specify the link parameters like you would for any type of link and you're done.

Be sure to test the hot spots in your browsers. I haven't used image maps in a while so there may have been some changes in the browsers that break the hot spots, but they did work fine on my PC using Chrome, IE, and Edge.

Wednesday, November 1, 2017

More Best Practices for Starting to Work with MadCap Flare - Standards


Flare has so many options that it can be hard to decide where to start, even if you've taken a class and especially if you haven't. New Flare users often just jump in. But this can get you off to an inefficient start, perhaps even a bad start, and create problems that ripple down to later projects.

I recently wrote a post for MadCap’s MadBlog that reviewed best practices for starting to use Flare. (See https://www.madcapsoftware.com/blog/2017/10/12/madcap-flare-best-practices-starting-a-new-project-from-scratch/) I expanded that post into a longer white paper for MadCap. (See https://assets.madcapsoftware.com/white-papers/White_Paper-7_Best_Practices_for_Starting_Your_First_MadCap_Flare_Project.PDF
In this post, I’ll take the topic of best practices further by expanding on the Standards section of the white paper. The original MadBlog post, the white paper, and this blog post are based on twelve years as a certified Flare consultant and trainer and eighteen years of hypertext consulting and training pre-Flare. However, always consider your specific situation before following any suggestions. With that, let's look at the standards issue in more detail.

The more you standardize, the more consistent your projects will be and the less authors will have to guess about what setting to use for a given task or feature. Things you might standardize include:

  • Graphic file formats – Many graphic formats are available today and Flare supports most or all the ones that you’re likely to use. The traditional approach is to use GIF for screen shots and JPG for photos. This works but you’re maintaining two sets of files, GIF and JPG.

    You may find it more efficient to use PNG for all graphics, including those for your print outputs. A PNG’s quality may not be as good as that of an EPS but your users won’t know because they haven’t seen the EPS so they won’t have anything to which to compare the PNG.

  • Conditional build tag usage – Condition tags are the core single sourcing feature but they can go out of control if you don’t set rules for their use. (I’ve talked to two firms this year that used tags with no initial rules about when to insert and how to call them. One company had a project with about 1,000 topics and 1,500 “unruly” tags. The other had about 1,000 topics and 15,000(!) such tags. The result was that new authors couldn’t figure out what tags to include or exclude for a given target and when to add new tags.)

    Creating and inserting tags is flexible – you can apply tags to a character in a topic, a paragraph, an entire topic, a group of topics, a folder, and any other element in a Flare project. And it’s easy – assign a name, pick a color, add an optional comment, and you’re done. In fact, it’s so easy that new authors often gloss over the crucial first step – defining what they’re trying to do and documenting it. So my suggestion is to first decide what you want to do, then define rules for inserting and using the tags, such as the smallest element you can tag. Document this. And test the results to make sure you’re getting what you expect.

  • Variable and snippet usage – Two excellent points from Craig Wright (https://www.straygoat.co.uk).

    “Try to plan your content reuse at an early stage, especially if there are multiple writers involved. It’s no good creating snippets if the other authors aren’t aware of them.”

    and

    “Make sure your snippets are well organized. If authors struggle to find the snippets they need, they may create their own and duplicate existing content.”

    A few comments of my own regarding Craig’s points:

    o   Get all authors involved in the planning early on.
    o   Define the variables and snippets in two groups – project-specific and shared.
    o   Set up a parent/child project structure using the Flare Project Import feature and put shared variables and snippets in the parent project for easy downloading to the child projects.
    o   Let all authors know when a new variable or snippet has been added to the shared sets.
    o   Make sure that all authors know that any changes to shared variables or snippets must be made by the “owner” of those files, not by the individual authors.
    o Make sure that the snippets are clearly named.
  • Index entries – My experience is that traditional indexing is declining among Flare authors, with search taking over. This makes sense since search is easier to implement, but an index can do things that a search can’t. For example, if I refer in a topic to a sandwich made of cold cuts on a tubular loaf of bread as a “sub”, searching for “hoagie” won’t find the topic because the search is looking for the search term in the topic text. But an index lists keywords attached to the topics rather than terms in the topics, so it’s easy to add the keyword “sub”, plus the keyword “hoagie, see sub”, and so on. This makes it more likely that users will find the right topic. (Flare does let you add search synonyms but this can be a tedious job.)

    If you’re going to create indexes, define some rules to make the entries structurally consistent from project to project. Here are a few:

    o   Decide if the verb should use the infinitive (“to print”, then remove the “to”, leaving “print”), or the gerund (“printing”). I prefer the infinitive but that’s up to you.
    o   Decide whether the noun should be plural (“documents”) or singular (“document”).
    o   Decide whether to use sub-entries. For example, the term “BBQ” might be a first-level index entry, with “Carolina”, “Tennessee”, and “Texas” as sub-entries. Note that you could also use those sub-entries as first-level entries – e.g. “Carolina BBQ”, “Tennessee BBQ”, and so on.
    o   Consider using inversing. If you include the first-level entry “print dialog box”, include “dialog box” as a first-level entry with “print” as a sub-entry below it.
  • Hyperlinks vs. cross-references (xrefs) – Hyperlinks have been with us since the beginning of online help but they have two limitations.

    o   The link text doesn’t update if the title of the target topic changes. Let’s say you link the term “sub” in topic A to the “Subs” topic. You then change the title of the “Subs” topic to “Hoagies”. But the link term remains “sub”. You must find and change it by hand. In contract, a cross-referenced term is programmatically linked to the title of the target topic, so changing the target topic’s title automatically changes the link term too.
    o   A hyperlink keeps the format of a hyperlink when you output to print, such as PDF, and the link works if the user is viewing the material on the screen. But when the user prints the material, the link obviously doesn’t work. But a cross-reference will literally change its format from a link style to a page reference – “information about spaniels, see page 225”.
So a cross-reference is a better choice if you generate online and print targets. The limitation is that a cross-reference won’t work if you create a link from a topic in a target to an external file, like a URL or PDF. In that case, you must use hyperlinks. That limitation aside, cross-references are the best and most flexible choice for links.

  • File naming – Setting file naming conventions is, surprisingly, one of the hardest tasks in working with Flare. There are two naming issues, programmatic (thanks to Stephanie M.), and semantic.

    o   Programmatic conventions are straightforward. Use all lower case or mixed case? Can multi-word file names use spaces, use underscores in place of spaces (file_name), or use “Camel Case” (FileName). Check with your IT department.
    o   Semantic naming conventions, to indicate what a file contains, is harder, and you’ll want to involve all the authors in the process. For example, you might decide to name graphic files by the name of the screen followed by the type of screen, such as “Dialog Box.” The result is “Print Dialog Box”, easy to find in a list if you know the name of the screen that you want. Alternatively, you could name graphics by the type of screen followed by the name of the screen, such as “Dialog Box – Print”, easy to find in a list if you know that the desired screen is a dialog box but don’t remember which one.
Two final planning thoughts in addition to documenting your standards, getting trained, joining a user group, and contacting support as discussed in the white paper:

  • Decide what your priority and secondary output targets are. Some features, like togglers, work fine online but not in print. So deciding on your priority target will help guide your selection of Flare features.
  • Decide if mobile is in your future. If it is, note that some features, like popups, don’t work on mobile devices. So knowing if you’re going mobile will also help guide your selection of features. Note that this can apply in other project areas as well, such as making sure that all movies you create using Mimic are in HTML5 format because SWF format won’t display on iOS devices.

Conclusion

I’ll partly repeat what I said at the end of the white paper – Flare is a big powerful tool. If you’re new to it, it may not be obvious what can even be standardized. By following the suggestions in the white paper and here, you’ll help get your Flare work off on a sound footing and help keep it that way.

Monday, October 30, 2017

“Perfect vs. Good Enough” – Writing Quality in the Online Age - Part 2


This is part 2 of a three-part post examining the issue of “perfection” in content creation in the online age. 

The first part, which I posted on October 10, is a column I wrote in 2001 discussing an event from 1998. (Stay with me here...)

This second part is a column that I wrote in 2009 discussing what had changed since the first column in 2001. Look for the third part, in late November, to revisit the issue of “perfection” in light of emerging trends in 2017.

In this post, I’ll list the core points of the Wired article and some ideas about their impact on technical communication. First, the Wired article…

“…It’s … the latest triumph of what might be called Good Enough tech. Cheap, fast, simple tools are suddenly everywhere. We get our breaking news from blogs, we make spotty long-distance calls on Skype, we watch videos on small computers… The low end has never been riding higher.

So what happened? … technology happened. The world has sped up, become more connected, and … busier. As a result, what consumers want from the products and services they buy is fundamentally changing. We now favor flexibility over high fidelity, convenience over features, quick and dirty over polished. Having it here and now is more important than having it perfect. These changes run so deep and wide, they’re actually altering what we mean when we describe a product as “high quality.”

And it’s… everywhere. As more sectors connect to the digital world… they too are seeing the rise of Good Enough tools … Suddenly, what seemed perfect is anything but, and products that appear mediocre at first glance are often the perfect fit.”

Two examples from the article…

·         MP3, whose audio quality is lower than the CD standard but whose greater file compression lets us cram hundreds of songs into devices the size of a pack of cards.

·         The netbook, with minimal storage and power but which is light, portable, and cheap compared to traditional laptops that have more features, most of which may go totally unused.

The examples offer “flexibility over high-fidelity, convenience over features, and quick and dirty over slow and polished” and each has altered its market or created new markets. How might these factors affect technical communication? Here are three ideas – none new but, based on my training and consulting experience, worth repeating:

·         A major change since 2001 is the appearance and partial acceptance of user-generated content for online use. “Let the engineers write the doc” has been a laugh-getter for years within technical communication but the idea keeps coming up for one good reason – the engineers (the subject matter experts) know the material. And their content has now been appearing for years in blogs, wikis, and tweets.

I don’t see user-generated content replacing traditional online documentation/help but extending it. The documentation/help will still contain stable core content but link to user-generated content in blogs or wikis containing new, changeable content. Technical communicators and user-authors form a virtual team. If you create online documentation/help but don’t link it to your company blogs or wikis, take another look.

Similarly, video and animation have been around for years but not often used because of the costs and required skills. But lower prices and simpler tools are putting video and animation into more hands – e.g. user-generated. It may be “movies” created quickly using tools like Adobe Captivate, TechSmith Camtasia, or MadCap Flare, or from video bloggers. (YouTube may also be a source. You may not find the perfect video there, but there are so many clips about almost any topic that you may find one that’s good enough. The volume of clips provides flexibility, and the material is available quickly, even if the production values may be “dirty”.)

So rather than discount the idea of user-generated content, we should be actively helping to create, organize, use, and distribute it in the first place.

·         Software-driven writing features like templates and style sheets have existed for years but are still not used as often as they should. One reason is that the settings in these control files are often not quite “right.” Something in your material deviates from a setting in the control files. You could modify the setting, but it’s often easier to set up the non-standard material by hand. The result? You get perfect content, but at the expense of losing the consistency and automation provided by the control files.

Instead, consider setting up your control files to handle your common needs and ignore or modify other needs that are too difficult or marginal to handle in the control file. For example, you might create a “first-paragraph” style with extra space above for use in hard-copy, but can you replace that style with the “body” style and live with the “good-enough” result?

So the results may lack the perfection that you got by hand-tweaking the material, but you get the good enough, quick-and-dirty convenience of bringing programmatic control to your writing tasks. (Wired made an interesting point about users coming to accept MP3 quality as the standard rather than the higher quality of CD because they used MP3 more and got used to it. As more and more readers get material online, they may come to accept online style quality as the standard.)

·         Finally, consider lowering your writing standards – not to write badly but to change the definition of quality, standardize that definition, and write to it.


Summary


Many technical communicators started in hard-copy and transitioned to online, a transition that involved some hard changes including:

·         Adding tasks once performed by other people, like editors, to the writer’s workload.

·         The speedup of the work, losing the time we might once have had to get material “perfect.”

·         The appearance of media like blogs and wikis whose need for immediacy runs counter to the idea of perfecting the writing.


Since the old column appeared, I’ve seen more and more technical communicators accept the idea of “good enough.” But many still fight it, which is a losing battle. The field has seen many changes, each fought but not stopped. This is one more. If we fight it, the change will occur but without us. That would be a shame because these “good enough” technologies and methodologies are actually fun and highly challenging.

Wednesday, October 25, 2017

Correction To My Post About Flare 2017 R3


In my post about Flare 2017 R3 on Nov. 24, I said:

"If you copy the content in this topic, paste it into Word, and generate the readability statistics in Word, you’ll get different results. When I tried it, Word gave a readability of 65.1 and a grade level of 7.0, both still excellent but different from Flare... This may be caused by Flare’s using the same "Flesch Reading Ease” and “Flesch-Kincaid Grade Level” algorithms as Word but with different options enabled."

As it turns out, the problem is not one of having different options enabled in Flare vs. Word but rather the fact that Flare and Word interpret what a "sentence" is somewhat differently. So the feature is still as useful as I said it was in yesterday's post, but the Flare and Word results are not directly comparable.

Tuesday, October 24, 2017

Some New Features in MadCap Flare 2017 R3


MadCap released Flare 2017 R3 a few days ago. In this post, I’ll look at two of the new features that I think are most useful.

Text Analysis

In the past, one problem that I had while writing topics was that I couldn’t determine the readability of the topic content. Flare didn’t offer a readability checker. I had to output a Word target and run that through Word’s readability checker. This process worked but was a bit clumsy. The new text analysis feature seems to offer a simple solution to that problem.

Selecting Text Analysis on the Tools ribbon opens the Text Analysis pane, shown below.



I selected the readability scores option for one topic (from the basic training class), shown below, with the results also shown below.


Flare shows good results with a green bar color, fair with yellow, and poor with red. So this topic has a fair reading ease score of 76 and a good grade level score of 3.9. (Both actually excellent.) I can check any content from one topic to an entire project.

Be aware of one thing when using this feature. If you copy the content in this topic, paste it into Word, and generate the readability statistics in Word, you’ll get different results. When I tried it, Word gave a readability of 65.1 and a grade level of 7.0, both still excellent but different from Flare’s results. This may be caused by Flare’s using the same "Flesch Reading Ease” and “Flesch-Kincaid Grade Level” algorithms as Word but with different options enabled. (We can’t yet modify those options in Flare.) This peculiarity aside, I’m delighted to see the text analysis feature because it simplifies my Flare workflow.

Style Inspector

The Style Inspector is a short-cut way to perform stylesheet tasks without opening the full Stylesheet Editor. It lets you see what styles your text is using, modify a style’s properties, add new properties to a style, add a comment to a style, even convert local formatting to a style on the stylesheet.

Selecting Formatting Window in the Styles group on the Home ribbon opens the Formatting pane with the Style Inspector tab selected, as shown below.


In this example, I put the cursor on the topic’s title in the left pane and:

  • The Style Inspector on the right tells me that the title uses h1, the font-size is 140%, and so on.
  • There are no local style attributes, as indicated by that empty pane at the top.
  • I could add local formatting by clicking the + sign in the top pane or an additional property by clicking the + sign in the lower pane.
  • I could change the value of one of the properties by clicking the ellipsis to the right of that style.
  • I can see what style sheet is controlling this style, here “ipswitch_styles.css” and see the path to that stylesheet by hovering over its name.
  • I can add a comment to a style by clicking any property of the style, right-clicking the style itself, and selecting Add Comment. You must click on one of the properties first.

All without having to open the Stylesheet Editor. (However, the stylesheet opens in the Stylesheet Editor if you add a property or change the value of a property since you’ll have to save the stylesheet to register that change or addition.)

Summary

I like how the Style Inspector makes it easy to manage my style usage. Personally, I still prefer to go into the full Stylesheet Editor but using the Style Inspector means I don’t have to. That’s useful if you’re new to styles and find the Stylesheet Editor overwhelming.

I especially like the text analysis feature because it’s completely new and solves a problem – the inability to get readability statistics in previous versions of Flare.

Between these two features, plus Microsoft Excel file import, last action repeat, a thesaurus, and some snazzy new templates, Flare 2017 R3 is a solid and useful release.
  

Tuesday, October 10, 2017

“Perfect vs. Good Enough” – Writing Quality in the Online Age

Part 1


In August 2009, Wired Magazine published an article entitled “The Good Enough Revolution: When Cheap and Simple is Just Fine” by the Wired Staff in the Gear column, 8/24/09, at https://www.wired.com/2009/08/ff-goodenough/.  Its theme – “cheap and simple beats perfect almost every time.” That article reminded me of a column I wrote in 2001 (“’Perfect vs. Good Enough’ – Writing Quality in the Online Age”) that discussed why technical communicators needed to change our definition of quality for the dot-com era.

On rereading, the 2001 column still seemed relevant. So, this column, part 1, presents the core points from the old column from 2001. Part 2 will revisit the 2009 column to present the core points of the Wired article and how they might apply to technical communication. Part 3 will revisit the issue of quality in the emerging age of taxonomies and semantic markup.

First, the old 2001 column, with my comments in italics.

Background


I typically get one or two calls per week from prospective clients or people looking for writers with certain skills. Three years ago (1998), I got a call from a dot-com looking for a “content provider.” It was the first time I’d ever heard that title so I laughed and said “So you’re looking for a writer?” and was taken aback when the caller vehemently said “No! We don’t want a writer.”

I asked why. The answer – “… writers get too focused on perfection… we don’t have time for. If we wait until the material is perfect, our competitors will beat us to market. We do not need it perfect; we just need it good enough.”

I mentioned that conversation often. Two people used it as the basis for presentations in the Bleeding Edge stem at the 2001 annual (STC) conference – one discussing the issue from a writing perspective, the other from a tools perspective. Here, I discuss it from two other perspectives – trends and standards.

Trends


Four major trends affect the issue of writing quality:

·         Time-to-market is getting shorter.

·         Editorial positions are being cut back or eliminated in many companies.

·         Single-sourcing is becoming increasingly complex.

Single-sourcing isn’t new. If you used RoboHelp to create WinHelp and hard-copy in 1995, you were single-sourcing. But today’s single-sourcing technologies work best with rigorously structured content. We can no longer get away with “winging it”.

By supporting “good enough” as opposed to “perfect”, isn’t winging it exactly what I am calling for? But it’s not winging it if you write to a standard, just that that standard may call for “good enough.”

·         New competitors are entering our field.

Technical writing was once unglamorous and fairly low-paying. Today, companies are starting to view content – including documentation – as a strategic asset. That shift has attracted consultants looking for new business. But technical writers also want that work.

Outsourcing is a new competitor. Technical writers are upset over the perceived lower quality of outsourced material, and lost jobs. But consider the business perspective. If outsourced material has 50% of the quality but is written at 25% of the cost, a company may decide it’s a worthwhile tradeoff.

What are the effects of these trends?

·         Shorter time-to-market means less time to write perfectly or fix stylistic inconsistencies. (Without editors, there may be no one to fix or even notice those inconsistencies.) So we need to define the material’s look and style before the project starts. We need standards and consistency at a human level.

·         Increasing single-sourcing complexity means that consistency and simplicity are key to getting our material into a form for re-use. We need standards and consistency at a structure and format level.

·         Consultants often use formal methodologies to do their work and help sell their services. We need standards at the business level.

Defining A “Perfect vs. Good Enough” Standard


Few companies have formal writing standards. Even those companies that do often don’t use them. There seem to be two reasons for this.

·         There’s a lot of creativity and subjectivity in writing, so how do you define “good”?

·         Many writers dislike tools that measure writing quality. This may be due to a reluctance to have a creative process measured by machine, bad experiences with a tool, or antipathy toward a tool’s vendor.

But setting documentation standards can let us do two things:

·         Determine how to change our processes to compete with the new entrants in the “content” field and participate in emerging markets and niches.

·         Define measurable standards to help justify why technical writers should do the work, or at least participate in it.

These standards should do three things:

·         Establish a baseline. What is “perfect”?

·         Define acceptable and measurable deviations from the baseline. Formalizing such deviations – a maximum acceptable percentage of passive voice, for example – will help improve consistency.

·         List and describe tools, especially third-party tools, that let us measure the baseline and deviations.

These standards could be created in two ways.

·         Each company defines its own baseline, deviations, and tools as part of its style guide. However, many companies don’t have the time to do this.

·         An organization, such as the STC, could define a “perfect” baseline standard and make it available to members to use as is or to define their own deviations.

Summary


Because of the nature of writing, our profession has always accepted a subjective definition of quality. But changes in the market and technologies are starting to undermine that viewpoint. We’re going to have to confront this issue at some point. Now would be a good time, while we have time to do so thoughtfully and deliberately.

The old column ended here. In part 2, I’ll look at the core points of the Wired article and some ideas about their impact on technical communication.

Tuesday, September 19, 2017

Four Management Challenges in Implementing Information 4.0

Information 4.0 is a new concept but some of the technologies and methodologies that it encompasses are available and implementable today, albeit in early forms. But before that happens, Information 4.0 will face multiple challenges, just as online help and the web did in the 1990s.

In this post, I’ll discuss four implementation challenges on the management side:

  • Defining clear and consistently accepted terminology.
  • Demonstrating support for the company's strategic and business direction.
  • Dealing with problematic senior management biases.
  • Establishing and following standards, metrics, and analytics.

Defining Clear and Consistently Accepted Terminology

New technology often sounds like confusing gibberish.

  • Twenty years ago, and even today, there was confusion over “WebHelp” versus “Web Help”, for example. Because of that confusion, many companies bought the wrong tools, hired the wrong people, or just went off in the wrong direction.
  • Today, there’s confusion over the meaning of “mobile”. Is it an app? Responsive online help on a laptop and a mobile device? Something else? I recently consulted at a large manufacturing firm that brought me in to help assess its readiness to go mobile. One result was the discovery that the different divisions had totally different interpretations of the term.
  • Information 4.0 promises entirely new levels of terminological confusion. Is “molecular content” the same thing as a topic? What’s “dynamic” content? And so on.  

Until everyone agrees on the meanings of the terms being used for an Information 4.0 implementation, it will be difficult to show support for the company’s strategic and business direction. This means it will be almost impossible to do anything else. So any Information 4.0 effort needs an education component.

Demonstrated Support for the Company’s Strategic and Business Direction

Information 4.0 is cool. But that won’t be enough to build management support because management is typically being pressed to support other initiatives too, many also cool. It’s crucial to show, concretely, how Information 4.0 will support the company’s strategic and business direction. That’s going to require careful analysis of the company’s operations beyond technical communication.

Dealing with Problematic Senior Management Biases

Even if senior management supports an Information 4.0 effort, we may encounter biases that affect that support. (In the early days of business computing, managers didn’t want to use computers because that involved typing and the bias was that typing was secretarial work. Renaming “typing” to “keyboarding” got past that bias and made typing – on a computer – cutting edge.)

For example, it will be crucial to present Information 4.0 as dealing with “content” and “user support”, not “documentation”. No one cares about documentation. But despite your efforts, management may still view Information 4.0 as documentation-focused, not realizing that “documentation” today is more a combination of content creation and programming. If so, it will be hard to get management support. By way of illustration…

I was contacted by a company whose online help was created using a long-dead version of RoboHelp. Users complained that the search didn’t work well and there were problems in the code. The company wanted to convert the help to Flare to get better search results and clean up the code to future-proof the content, both supposedly good things.

The company turned down the proposal on the grounds that it was too expensive. The problem was that they saw their help as documentation rather than as a strategic resource and gave it a far lower priority. The upshot? Their staff would do the conversion. Unfortunately, the staff was bright but didn’t know RoboHelp, Flare, or code so the effort was likely to be slow and inefficient at best.

In that tale is an example of how management bias may harm even efforts that management wants. And Information 4.0 is far more complex and unfamiliar than online help, so bias is likely to be still more of a problem.

Standards, Metrics, and Analytics

In the mid-1990s, online help and the web were so new that few companies had standards or metrics by which to measure them. And analytics barely existed.

Today, however, getting management support for an Information 4.0 effort will require showing support for your company’s business and strategic direction. (That may not always be the case. In 2002, I spoke with two people from an aircraft builder whose CTO was so impressed with mobile that he directed that it be implemented on the manufacturing floor without cost-justification. So you may not always have to demonstrate support, but it’s the safe way to bet.)

Demonstrating that support often requires quantitative data, ideally numbers that translate to increased revenue or reduced expenses. Information 4.0 is so new that few standards exist, and thus few metrics or analytics. Yet Information 4.0 has a lot in common with today’s online help and web efforts, and may be able to use some of their standards and metrics. The biggest problem I’ve found with metrics for any purpose, let alone Information 4.0, is resistance from people who don’t want to be measured.

Summary

Information 4.0, like any new technology, is fun to speculate about and fulfilling to help emerge. There are many interesting challenges on the development side and the impact on tech comm. I’ll look at these in later posts.


But none of them matter if you don’t sell management on the idea in the first place.

Wednesday, September 6, 2017

We’re Going Mobile! Great! But What Does That Mean? And Are We Ready?


So, your company has decided to take its documentation mobile. Great! But has the company considered:

        What does “mobile” mean? People often assume that “mobile” means an app on a smartphone but does everyone share that definition? If not, different groups can wind up going in different directions.

        How do you plan to go mobile? Creating responsive versions of the documentation, converting the online documentation to an app, creating a “true” app, or something else?

        Should your content authoring practices change? You may be authoring in ways now that violate good practice, such as local formatting in Word, but that have been working until you decide to go mobile.

        Will your business practices support an organized and maintainable mobile effort? If not, the move to mobile is likely to be a one-off that wastes resources and loses management’s support.
In this post, I’ll briefly discuss these questions. The post is based on the “We’re Going Mobile! Great!...” presentation that I gave at the STC annual conference in Washington, DC in May, 2017 and the TCUK conference in Nottingham, England in September 2017.

What Does “Mobile” Actually Mean?

It sounds silly, but poll everyone involved to make sure they’re defining “mobile” the same way. Often, they may not be and the result can be chaos if you’re trying to set up a company-wide mobile strategy.

How Do We Plan to Go Mobile?

There are three primary approaches – responsive output, converting online documentation to an app, and creating a “true” app.

1 – Responsive Output

Responsive output means creating one online document or web site that can detect the properties of the device on which it’s displayed and automatically reformat itself accordingly. This can be very useful because if your material has to be displayed on desktop PCs, tablets, and smartphones, you only have to create one output rather than one output for each device.

And, depending on your authoring tool’s features or your code skills, you can not only change the screen layout, such as collapsing the menu, but change the layout of the content, such as changing from a horizontal to a vertical format, and even change wording, such as changing “click” when the material is displayed on a PC to “tap” when it’s displayed on a mobile device. All automatically.

2 – Converting Online Doc to An App

Because so much online documentation is primarily text and graphics, we tend not to think of it as being suitable for an app. Yet many apps are largely text and graphics. Check out the Messier List and Encyclopedia Britannica apps for example.

How can you convert your online documentation to an app? Two quick options:

·        If you use Flare, you’ll use the cloud-based PhoneGap Build (https://build.phonegap.com/). See my May 2017 post on MadCap’s MadBlog at https://www.madcapsoftware.com/blog/2017/05/18/convert-madcap-flare-target-mobile-app/.

·        If you use RoboHelp 2015+, you’ll use the built-in PhoneGap (http://phonegap.com/). For information, see this post by Robert Desprez – http://tinyurl.com/h2y27o2.

·        For general information, see PhoneGap Essentials by John Wargo.

Not everything will convert smoothly. Popups convert to hyperlinks. Some head styles converted to italic when I converted a RoboHelp 2015 project, though this may have been fixed in v. 2017. But the main content, structure, and features converted surprisingly well.

3 – “True” Apps

Need the look and features of a “true” app? The last few years have seen the appearance of code-light or code-free app development tools. These are sometimes referred to as DIY (do-it-yourself) app tools, or categorized by Forrester Research as Rapid Mobile App Development (RMAD) tools. (Look for a future post on the subject of RMAD tools.)

RMAD tools have two uses for the purposes of this discussion.

        Let non-programmers create apps.

        Let programmers create apps by making the interface creation, workflow, and data access tasks simpler than working in code in order to free up time to concentrate on the code-heavy tasks.

By way of disclosure, I’m certified in one RMAD tool called ViziApps (www.viziapps.com). For a list of other RMAD tools, see “10 simple tools for building mobile apps fast” at http://tinyurl.com/hzz4j5c

Why create true apps rather than using responsive output or converting your help to an app? Two primary reasons.

        User expectations – If you say “app” to most smartphone users, they’ll have expectations about the look and features that responsive output or converted help may lack.

        The need for new capabilities such as location or orientation sensitivity, a built-in camera, RSS feeds, transaction processing, and more.

What Effects Might Mobile Have on Your Development Practices?

If you plan to make your content mobile in an efficient and maintainable way, you may need to make some changes in how you create and maintain that content. Some examples:

        No more hacks – Hacks may be impressive but they’re often a bending of good coding practice that can be hard to maintain and may not work as you upgrade your authoring tools or code version. As someone once said, “A hack is a one-off; good coding is forever.” Eliminate existing hacks and make it a policy that new hacks are not permitted.

        No more local formatting – Local formatting is inefficient and overrides the styles in your CSS. This is not a not a mobile issue per se, though it bulks up files and may slow downloading. But it’s just bad coding practice and may break something in the future.

        Replace local formatting with styles, which may mean cleaning up your CSS.

        Rethink your writing style. Make it shorter, more granular, and more focused.

        Eliminate excess content.

        Tables can be hard to fit into small screens, so rethink what purpose your tables serve and how to use them. If your tables are containers for multiple content pieces, only one of which is used at a time, can you replace your tables with lists of links or searches?

        Consider changing navigation – Indexes are being replaced by search. Does this affect you?

        Use up-to-date, commercial tools – Look for tools that offer new features like responsive output and get rid of outdated tools. Be wary of tools with proprietary features that may not translate going forward. If you use such tools, be wary of leap-frogging multiple versions to get up to date or switch to a different tool.

Do Your Business Processes Support Mobile?

You can be okay regarding definition, technical approach to conversion, and cleanup of development processes and still have the move to mobile fail because it isn’t supported by your business processes. Some examples:

        Management buy-in – Have you given senior management sound business/strategic reasons for going mobile in order to justify the effort and build long-term support? If not, the effort will die.

        Training – Have the authors been formally trained in the correct and effective use of their tools? Peer-to-peer training may work if the trainers are experts, but too often this simply promulgates bad practices.

        Standards – Have authoring standards been clearly defined, promulgated, and enforced across all authoring groups? Without such standards, it’s almost impossible to share content between groups and projects.

        Development metrics – Are there clear, focused metrics?  If not, it’s very difficult to identify weaknesses in the development processes. Something as simple as time-per-content-unit is a convenient way to keep track of the effort and resources required.

        Usage analytics -  Do you collect and analyze usage data to find out what users, if any, are using what material? Without such data, you’re basically throwing your mobile content into the darkness and hoping for the best.

        Governance – Is there any formally defined process for managing the workflow and ensuring that material meets internal and any external requirements?

        And more…

Summary

It’s easy to go mobile – buy an authoring tool, figure out how to use it, and convert your content to a mobile format. Unfortunately, this approach can be very inefficient and lead to results that are neither maintainable or reproducible.

Similar problems arose in the early days of online help in the mid-90. But back then, much of the effort was experimental, user expectations were minimal, and schedules were loose. Today, “mobile” is a much more culturally accepted form of presenting content, which means that user expectations have been conditioned by a decade of smartphones, and users want their mobile content now.

Proper planning before going mobile will help your company better meet those expectations.


Tuesday, September 5, 2017

Beyond the Bleeding Edge Returns

Beyond the Bleeding Edge was a conference session that I ran at the STC’s summit from 1999 until 2014, and a column I wrote for the STC’s Intercom magazine from 2000 to 2015. The goal was to introduce technologies that were new to tech comm – on the leading (or bleeding) edge and beyond – such as XHTML, WSDL, JavaHelp, haptic interfaces, the W3C RDF metadata standard, and more.
The Bleeding Edge is now Hyper/Word Services’ technology blog. Look for a new post every 3-4 weeks on various technologies, tools, and methodologies, with a focus on mobile content and the Information 4.0 concept, plus whatever else seems appropriate.
Technology is fun!

Tuesday, April 11, 2017

Welcome to MadCap Central

NOTE 1: This article was originally published in ISTC Communicator, Spring 2017.

NOTE 2: Since I wrote this article, MadCap has released v. 2017 of Flare, which does not change the interaction with Central, and a new version of Central which adds support for Slack. Central's basic concepts and features remain the same however.

If you’re a MadCap Flare user, you’re likely to have run across two issues with your projects.

Issue one has to do with safeguarding your projects, getting them off your local PC and on a server to avoid losing the project files if your PC is damaged, and making them available to additional authors. The traditional answer is to get a version control system like Subversion or Git, but what if you don’t have the budget or IT support? From my training and consulting experience, many MadCap Flare shops are in this position.

Issue two is project management – how to keep track of the projects, tasks, and staff needed to create your projects. Many authors keep project to-do lists but they’re hard to manage and easy to lose, even for a single project with one author. It becomes still more difficult if you have one project with multiple authors, or multiple projects. How to keep track of everything?

MadCap Central is MadCap Software’s answer to both issues. MadCap Central combines project management and version control in one surprisingly easy-to-use package that integrates with the latest version of Flare, version 2016 r2. (If that number seems odd after years of integer versions like 10 and 12, it’s because MadCap has adopted an Agile release policy that promises incremental releases with new features and bug fixes several times a year.)

Let’s take a look at how MadCap Central offers version control and project management.

Version Control Features

Look at Flare 2016 r2’s View ribbon and you’ll see the new MadCap Central icon. Clicking it opens the MadCap Central pane where you can log in to MadCap Central. (You can also click an icon on that pane to quickly open the MadCap Central portal page in a browser and log in there.) Once you’re logged in, you’ve got several options from the MadCap Central pane’s local toolbar:



The principal options are:
Upload this project to MadCap Central – Click  to move the project into (bind it to) MadCap Central. Once you do this, you’ll see a Source Control item on Flare’s menu. Clicking that item opens the Source Control ribbon, shown below, which lets you control the project’s interaction with MadCap Central.



 At this point, you’re using MadCap Central like any version control system.


Remove MadCap Central Bindings from Project – Click  to remove the link from Flare to the project in MadCap Central. You’d do this if you want to take the project back to local status for some reason. Removing the binding from a project does not remove it from MadCap Central; instead, it simply removes the link between MadCap Central and the project.


Import a project from MadCap Central – Click  to download a copy of a previously uploaded project. You’d do this if you hired new authors and need to give them access to the project, or if an author’s PC crashed and the project has to be re-downloaded onto the new PC.
Upload latest local files to MadCap Central – Click to move any changes made on the author’s local PC to the version of the project in MadCap Central. You’d do this to update the version in MadCap Central with the latest local changes.
Open the MadCap Central portal – Click  to open MadCap Central in your browser. You’d do this to quickly access MadCap Central’s project management features.


So MadCap Central is actually replacing a traditional version control system. And you can use it to actually host your output. So binding a project to MadCap Central and managing the version control aspect really does seem to be this simple.

Three points to bear in mind:

  • MadCap Central is in public beta as of the date of writing this article – mid-December 2016. My experience is that everything is working smoothly but, as in any beta, some oddities may emerge.
  • MadCap Software plans to provide a gigabyte of storage for each MadCap Central subscription, shared among the users associated with a subscription. That figure may change depending on the result of the beta.
  • MadCap Software hosts MadCap Central, handling all server administration for you and effectively acting like a shadow IT department. This saves you the cost and effort of hosting a version control system yourself. Note that if you have a mandate to use a version control system that’s already in place, you can use MadCap Central in conjunction with other tools like Subversion or Git.

Project Management Features

Once you bind a project to MadCap Central, you can access a wide range of project management features.

The Home page features that let you display a dashboard, shown below, containing various widgets with information about aspects of all or selected projects or users.



The first release lets you select from eight pre-defined widgets. (Future releases may let authors create their own custom widgets.) You can manage the widgets and filter the information they show.

The Project page has features that let you get a high-level view of all projects stored in MadCap Central, showing the team members and individual users assigned to projects, project status, build and publishing history, and more.




A build management pane lets you see the targets for a project and build one from Central.



The Tasks page has features that let you define tasks with priority levels, the person responsible for the task, start and end dates, and more. You can see these tasks in a task board, shown below.



You can also see the tasks in a calendar view to help you plan your schedule. You can also filter and archive tasks in various ways to focus on what’s important at a particular time and to be able to go back and review what you did for a project post-mortem.

The Users page lets you invite authors into MadCap Central, set their permissions, specify projects and teams in which they can participate, and more.

The Teams page lets you specify what users belong to what teams, send messages to team members, keep tabs on the activities performed by members of a team, and more.

Basically, there’s no one specific way in which to use MadCap Central as a project management tool. Its features let you view projects in many different ways depending on what information you’re looking for. (This is similar to MadCap’s Analyzer add-on tool. Analyzer offers many options; the ones you use are entirely up to you.)

Summary

MadCap Central is a well-thought out product that offers easy-to-use project management for Flare projects and an equally easy-to-use alternative to traditional version control systems. It will also serve as a platform for future enhancements to the project management and version control features. In summary, MadCap Central will add control and safety to your Flare projects and is definitely worth a look.

One obvious question – is MadCap Central worth it if you’re a sole author working on one project? In my opinion, yes, if only for the version control system aspect. In fact, that may be the strongest selling point if you’re a sole author because you probably lack the time to deal with the complexity of installing and managing a traditional version control system. The fact that MadCap Central does that installation and management for you is a huge time saving.

Note – For a more detailed look at MadCap Central, watch the introductory webinar. Download it from the list of recorded webinars. Go to http://www.madcapsoftware.com/resources/recorded-webinars.aspx#central and look for “Introducing MadCap Central: An Overview + MadCap Flare 2016 r2” dated November 17, 2016. There’s a second one as well, dated December 15, 2016.

About the Author

Neil is president of Hyper/Word Services (www.hyperword.com) of Tewksbury, MA.  He has many years of experience in technical writing, with 32 in training, consulting, and developing for online formats and outputs ranging from WinHelp to mobile apps and a broad range of tools.

Neil has been using, training on, and consulting on MadCap Flare since 2004 and is MadCap-certified in Flare and Mimic. He is an STC Fellow, founded and managed the Bleeding Edge stem at the STC summit, and was a long-time columnist and contributor to STC Intercom, IEEE, ISTC Communicator, and other publications.  You can reach him at nperlin@nperlin.cnc.net.