Transcript of Delivering technical documentation via an API

Below is a transcript of our podcast episode Delivering technical documentation via an API:

Welcome to the Cherryleaf podcast. In this episode, we’re going to look at documentation APIs.

In a previous podcast we looked at trends in technical communication, and we were debating whether to include documentation via an API as one of the future trends for 2018 and beyond.

We thought we’d explore it in a standalone episode, which is the episode that we have here. So we’re going to look at: What is a documentation API? Why you might want to use one some examples, and some of the tools and platforms that are currently available.

One of the challenges with this topic is there are actually a lot of content APIs around, and a lot of the information that’s transferred is content.

  • You have APIs for providing weather information: that the weather in a particular city is so many degrees, and it’s windy, or it’s cloudy.
  • And we have APIs for adverts. So there’s an API for Bing, where you can use that to get different adverts embedded onto a particular sites.
  • And there’s also APIs for platforms provided by organizations like the BBC and the Guardian,

And often this information is organized in pairs of data; a key and then a value for that data, stored in a text file, usually in a format called JSON. And in many ways this is what you might have previously called just “data”.

So we need to try and differentiate what we mean by documentation from that type of information. Differentiate the type of information and content that technical communicators provide. The type of information that you would see more in a instructional set of guides than in a weather report.

The definition that we’re going to use, or the focus that we’re going to take, is on the type of information that you might see in a user guide or an online help file, and that essentially is instructional, task based information, or reference, look up, information, and particular information that might be more than just a city and the temperature. So content that might need to be presented in tables, for example.

And again another challenge with this topic that can make it rather confusing is, of course, a lot of this can also be delivered if you wanted to automate it. And that’s one of the reasons why you’d use an API. You could automate it by using a chatbot, where that would be serving up the information, and potentially providing that information using voice rather than text, and we’ve done a podcast on chatbots previously; so we’ll leave that for this episode. Have a listen to our podcast on chatbots. We’ve also got a primer guide to chatbots as well, so do have a look at that.

So why would we want to use an API to deliver documentation? We can use a content management system today to deliver information. It will enable us to deliver it as web pages, as self-contained Help files, as PDFs, and a content management system can personalize content. It can narrow and filter the information to suit different users, individual users.

So what would an API give us over and above what we can use today with the content management system? To answer that question, a good starting point is to go back to what an API is. And in its simplest terms, an API, an application programming interface, is a way that two machines, or two pieces of software, can talk to each other automatically.

The use case or the situation where we might want to use an API is where we want our content to be used by another system. So that may be where there is a system that has a workflow and there is a need to provide the end-users with information and make decisions. A performance support role for the content. A number of examples of this might be that you have Salesforce.com as your platform for supporting end-users, for marketing and selling in your company, and you may have customized and adapted Salesforce to your particular situation; included the different products that you offer, the different prices, different types of customers, and so on, and you might want to provide specific information to your Support people or to your salespeople that can have on the page, as they’re going through a support call or a sales call, information from the instructional content, from the reference content, from what might have been in the past called a user guide.

Another example is one that was mentioned on another podcast, Scriptorium’s podcast, a case study on how they have worked with the American Joint Committee on Cancer. The AJCC provides a manual on cancer staging, related to whether somebody has Stage 1, Stage 2, Stage 3, Stage 4 cancer, and that information is used by providers of medical systems to help doctors make decisions. And the AJCC has converted that content into being an API, so that these providers of healthcare management systems can include this official content on what is defined by different stages and how you would make decisions to classify a patient. Having one of those, they made that information available as an API, so that the software providers can include it in there. And we will include a link to that podcast, that Scriptorium podcast, in the show notes.

Another situation may be that you’re using a platform like SAP, and that you have customized the SAP platform for your particular situation. So that it’s organized by the number of offices, or the number of factories that you have, or again the number of products. And to help somebody that’s perhaps defining the levels of depreciation in different countries for depreciating assets, or making decisions over a stock rotation, there is reference information in your system. Legal information they might need to be aware of company policies. Do’s and don’ts that that could be embedded into the SAP screens from an API.

So a common theme may well be that you want your information embedded into other applications. You might want information that describes different parameters as to when and where you’d make a decision. Issues around safety; it might be rail safety, it might be aircraft safety. Making sure staff conform to certain rules. Those are some scenarios where API delivered content might be useful. How can we use an API to deliver our content? Well, one approach is to use one of the platforms that’s used for content. A platform, for example, like a content API platform. If we’re using voice, we could look at the APIs that Amazon provides. And one of the ways in which Alexa is being used, is to provide instructions and information on recipes, or instructions on how to use a product.

But again we’re we’re veering into chatbots. Let’s move away from that.

Another platform might be the GatherContent API, which will interact with a number of systems. In particular, platforms that provide help desk type information. The team that have developed the ReadTheDoc’s platform for API developer documentation has a platform called EmbedAPI. And this enables you to embed content from your content if it’s on the Readthedocs website. And enables you to embed that content that’s hosted there into other platforms. And this is a way of making sure that’s API related documentation, which is often the type of content that resides on Readthedocs, is always up to date always there in these other applications.

What about platforms within the field of technical documentation more focused on user based instructional content? What do we have in that way?

Well, there are a few, but but not many at this stage. There is Paligo, and Paligo is a content management system in the cloud, and is based on DocBook. The content is structured in that way, and it’s possible to use the Paligo platform and its API, to have your content integrated with some of the most common help desk portals and with Salesforce.com. Mindtouch, which is a popular platform browser-based platform, again for providing help desk information and also user instructional information, that also comes with an API. And you can use the Mindtouch API to extend your product documentation so it’s included throughout the customer journey.

If you’re using Markdown to write your content, your choices are going to be more limited. Because there is this need to have this semantic wrapper around this content, this metadata, to say what information is there is. One platform that can do that, one called Forestry. The API for that is not publicly available, but there is a private API that’s available on request. So that may be worth considering if you want to write only using Markdown.

So that’s a very brief overview. We have these overlaps between other API systems that provide other types of content. We have overlaps with chatbots and voice based information. And it may be that documentation is API won’t really become distinct from those. But there may be, in the future, a need to distinguish like we have between those other forms, and provide our content via an API into other systems. It really depends if your content needs to be used by another system, if you need that situation of one machine talking to another.

We’d welcome your thoughts and your experiences on using documentation based APIs, and other content APIs, where they’ve been applied to technical documentation. So do share your thoughts. We have interviewed people in the past on the podcast, so there may be an opportunity to record some of your thoughts.

If you’d like to contact us, you can email us: info at cheryleaf.com.

If you want to see these show notes, with links to some of the topics that we’ve talked about, some of the products, you’ll find those at cherryleaf.podbean.com.

And if you’d like to know more about Cherryleaf, and our documentation services, the training courses, the recruitment side, and the project side, then you’ll find that on our website Cherryleaf.com.

So this is the last podcast episode for 2017. We wish you a happy New Year, and we’ll be talking to you again by podcast, and through other means, in 2018. Thanks for listening.

Incorporating the Stripe API look and feel into a MadCap Flare project

Back in July, we looked at creating an API documentation portal using MadCap Flare (see also: Example of API documentation portal using MadCap Flare) .

We done some further testing. We’ve created two new examples for  API documentation that had been generated with the Stripe API look and feel and imported into Flare:

To compare the two, here is the standard “Stripe API” left-hand Table of Contents when imported into Flare.

We’ve not made any changes to the default Heading styles from the source files. The stylesheets would needed to be modified to make them consistent with the styles used on the other HTML pages in the project.

Example project – API documentation portal using MadCap Flare

Note: This post follows on from two previous posts on creating a unified API documentation portal:

We’ve just uploaded an example project of an API documentation portal created using MadCap Flare:

The documentation portal includes API reference documentation that was generated automatically from a Swagger/OpenAPI specification file.

Whenever the REST API specification is updated, that content automatically updates itself in the Flare project.

Using MadCap Flare means you can provide a consistent user experience: for the reference, troubleshooting, getting started and tutorial content. Flare also manage the content, search, linking, pdfs, tables, flowcharts etc.

The steps are:

  1. Generate the API reference documentation in HTML format from the OpenAPI specification file. This could be generated automatically each day.
  2. Import the API reference HTML file into Flare. Select Link Generated Files to Source Files. This creates a connection between the original HTML files and the files that are created as a result of the import. Flare recognises when changes have been made to the source documents.
  3. Fix any initial CSS issues. The API reference HTML file links to a cascading stylesheet file. We found we needed to create a CSS file with the same name, as there were some issues with displaying the top navigation menu bar.
  4. Generate and publish your web site. You can run Flare’s “Build” command from the operating system’s command line. This means you can create a batch file with the necessary commands in it. Then you can use a scheduling tool to run the batch file automatically.

Further work could be done to improve the outputs:

  • We’ve not made any changes to the default styles for the PDF manual.
  • Amending the cascading stylesheet for the Stripe-style API documentation
  • Adding code samples.

See also: Cherryleaf’s API documentation writing services

GDS publishes its new design for technical documentation

The Government Digital Service has been working on establishing a standard design for its technical (i.e. developer) documentation. This content is for systems architects, developers and users of the GOV.UK platforms and APIs.

You can see an example at: GOV.UK Platform as a Service

Gov.uk technical documentation

Cherryleaf was given a preview of the new design a few months ago, when we ran an API documentation training course at GDS. We made a couple of suggestions, which look like they’ve been included in the final design.

The documentation has these main sections:

  1. Overview. This includes why you would use it, and the pricing plan.
  2. Getting started. This includes prerequisites and limitations.
  3. How to deploy
  4. Troubleshooting
  5. Managing apps
  6. Managing people

Elsewhere on the website is information relating to support, the product features, and the product roadmap.

As with other GOV.UK content, the team carried out research into what developers wanted, and they carried out usability testing. I understand the researchers discovered developers preferred content to be on a long, single page, and that they would be working in a two screen environment. Using long pages enables users to search and navigate with the keyboard, rather than the mouse. GDS also looked at other developer websites, such as WorldPay and Stripe, for best practice.

GDS is highly regarded in the technical communications community for its excellent work on the GOV.UK website. This means it is likely other organisations will copy GDS’s design for their own developer documentation.

 

Policies and procedures as an API

Here’s a trend that didn’t make our list of predictions for 2017 – having company policies and procedures accessible via an Application Programming Interface (API).

API is a term used to describe mechanisms that allow an application to access data or functionality provided by another application, system or service. For example, if your policies and procedures were accessible via an API, they could be embedded or used in other systems within your organisation. APIs offer connectivity, flexibility and future-proofing.

Instead of staff having to look up procedures in a manual or on an intranet, the official guidance or instructions could be embedded into the applications and forms they’re using. Developers could save time by connecting the application they’re developing to the API. They wouldn’t need to write the information, and staff would always be presented with the official, definitive policy or procedure.

You’re still able to create policy and procedure documents, as a web page or in paper format.

This prediction didn’t make the list because it relates mostly to business documentation rather than technical documentation, and we’re unlikely to see many examples of it within the next 12 months. In practice, the content might be managed by a headless CMS; however, the approach would remain the same. Perhaps the NHS and other organisations in the healthcare sector will be the first to take of this approach.

See also: Cherryeaf’s policies and procedures writing services

What do you think of this prediction? Please share your thoughts below.

Documentation as an API – the docsbot

In a recent presentation, Twilio’s Jarod Reyes and Andrew Baker mentioned their plans to make Twilio’s developer documentation available as an API. They plan to start with an API for code samples, stored in a github repository.

Making documentation available as an API means means users can create or remix their own versions of the documentation. For example, they could embed Twilio’s code samples. It also means those embedded code samples will be updated whenever Twilio updates those snippets of code.

Jarod and Andrew suggested something new that we’d not heard before – the API can also be used to create a “bot” in Slack, to help new users. The Twilio bot, currently in development, is called docsbot. If users type “lookup py” in the Slack command line, docsbot will reply with a message containing a code sample for the Python development environment.

Twilio's Slack docsbot

It relies on users knowing the relevant Slack commands, but it’s an interesting way of providing users with documentation when and where they need it.

See also: Advanced technical writing & new trends in technical communication training course 20th October