# Reading material ## 1. Publishing your work After completing your FHIR profiles, the next step will probably be to make them available to the world. Publishing your profiles will enable, for instance, app developers to build on your work. [Simplifier](https://simplifier.net) is a registry for all FHIR resources. It facilitates you in using FHIR more efficiently because of its ability to search and use previous work. Moreover, Simplifier can be used as a platform to work on your profiles with multiple developers and provide feedback on each other's profiles. To learn more about Simplifier, follow the [Simplifier module](https://simplifier.net/ui/ig/ProfilingAcademy/Simplifier/). ### 1.1 Uploading profiles from Forge Assuming you have used Forge to author your profiles it will be very easy to publish your work thanks to the integration of Forge with Simplifier. Besides Simplifier, Forge is able to publish to any FHIR server with the click of a button. After finishing your profile in Forge go to `File` at the top menu and click ``Publish to Simplifier.net`` (or press Ctrl + U instead). In the following screen you will be asked to give your Simplifier.net credentials. In case you do not have a Simplifier account, just register [here](https://simplifier.net/signup). Create a Simplifier project by going to your personal portal, opening the tab ``Your projects`` and clicking on the button ``Create a new project``. You can of course also use one of your existing Simplifier projects. Go back to Forge, and after you provided your credentials in Forge, click ``Connect`` and wait a second until the Status says ``Passed``. Now, you can select the Simplifier project in which you want to publish your profile. Click the save button to finish the upload. Forge returns to its editor screen and your profile is now online at Simplifier. {{render:01_how-to-publish.png}} ### 1.2 Publishing profiles on Simplifier If your profile is truly ready for the world you can mark it as ``Active`` on Simplifier. By default the profiles published from Forge will be marked as ``draft``. The next step will be to find your newly uploaded profile in your project at Simplifier. Go to your personal portal on Simplifier and select the project under ``Your Projects``. Click on your uploaded profile which can be found under the tab ``Resources``. In your profile page, click the ``Status`` button in the top right of the page and select ``Active``. Your profile is online and marked as ``Active`` at Simplifier. ## 2. Creating an Implementation Guide The next step in publishing and sharing your work is to create an Implementation Guide (IG). An IG is a set of rules about how FHIR resources are used (or should be used) to solve a particular problem, with associated documentation to support and clarify the usage. An IG provides documentation about the package and the individual profiles targeting FHIR implementers and system integrators. You can find some examples on the HL7 FHIR website. More information can be found in the [specification](https://www.hl7.org/fhir/implementationguide.html) and in our [blog post](https://thefhirplace.com/2015/02/13/fhir-profiles-and-implementation-guides). ### 2.1 Know your audience When you start writing your IG you should keep in mind the audience you are writing it for. IGs are mostly written for developers, who can use it to implement your solution. Use language that developers understand, add examples to clarify what is expected from them and add information about how they can validate their implementation. Also consider if you want to write the IG in your native language, a common language like English or even in multiple languages. As most developers in the world will understand English, using English can make it easier to share and implement your solution across the boundaries of your country. ### 2.2 Scope and format Next thing is to define the scope and format of your IG. IGs can be either written as documents (e.g. PDF) or webpages (e.g. a wiki page, a page on Simplifier or your own webpage). Given how convenient the FHIR specification is to read and link to, prefer webpages to documents when publishing. The scope of your IG depends on the scope of your project. In general, we define the following scopes for IG’s: |Scope|Description|Example(s)| |- |Strategy|A nationally scoped guide that provides a general overview and the strategic choices that are made. For example it describes the national infrastructure, security and privacy requirements. This guide will often reference more specific guides.|[MedMij afsprakenstelsel](https://www.medmij.nl/afsprakenstelsel/), [INTEROPen Care Connect API](https://nhsconnect.github.io/CareConnectAPI/index.html)| |Guiding principles|A guide that describes overarching guiding principles, such as regulations and basic components. This guide often serves as a foundation for future IGs.|[US core IG](http://www.hl7.org/fhir/us/core/), [DE Core LeitfadenBasisDE](https://simplifier.net/guide/LeitfadenBasisDE/Home)| |Subject|A guide that describes one subject. This guide describes multiple use cases and scenarios that are all related to this subject. For example, the subject could be medication or the IHE technical framework.|[Lab results Norway](https://www.hl7.no/fhir/profiles/Labresultat_og_rekvirent/Generated/Chapter.3.Profiles.Lab%20Results/composition.labresults.html)| |Use case|A guide describing a single use case and its interactions, data structures, vocabulary and testing. Examples of use cases are prescription or the IHE integration guide. |[ZorgDomein FHIR interface](https://zorgdomein.com/integrator/documentation/fhir-edition/fhir-specifications/)| ### 2.3 Content The content of your IG depends on the scale and scope of the guide (from national to product), its intended audience and the background of your organization (e.g. are you part of a vendor or a standardization organization). In general, an IG should contain information about the use case, its actors and interactions, data definitions (e.g. your profiles) and a set of examples. You can find a template for an IG here: http://implementationguidetemplate.azurewebsites.net. The following sections are relevant to include in your IG: |Section|Content| |- |About the IG|A general introduction| |Use case(s)|Description of the use case(s):
  1. Overview systems and architecture
  2. (System) actors overview
  3. Datasets and data elements (could be a link to elsewhere)
  4. Business rules, policy (technology independent), for example:
| |Technical implementation guidance|Section of the IG containing technical details:
  1. Per use case/transaction
  2. Sender and receiver responsibilities (functional requirements), for example:
  3. List of invocations (message semantics, interactions, operations, search parameters)
  4. List of profiles
  5. Terminology (ValueSets, ConceptMaps)
  6. Namingsystems
  7. Mappings
  8. Examples (instances) – crucial to understanding what is expected
| |Profiles|Description of all profiles:
  1. Introduction & scope
  2. Usage (explanation on how to use this profile)
  3. Canonical URL (to identify profile)
  4. Must support (more detailed explanation of the meaning of the mustSupport flag for this profile, as this element is not very specific in the StructureDefinition)
  5. Data structure itself (you can render it in one or more formats, such as table, tree, XML or JSON)
| |Registry|Description of other FHIR artifacts that are used:
  1. Summary tables of all conformance resources
  2. Capabilitystatements
  3. Structuredefinitions + extensions
  4. Terminology, valuesets, codesystems
| |Security|Details on security| |Appendix|One or more appendices| |Help|General guidance| |Contact information|Relevant contact information| ### 2.4 General requirements for writing implementation guides General requirements for an implementation guide are: * Provide some general documentation about the conformance package * Provide detailed documentation for each of the individual resource profiles * Include documentation from external sources, e.g. if our package has external references to (third-party) profiles published elsewhere. * Include dynamically generated content, e.g. UML diagrams, hyperlinks to related documentation etc. * Support identifying distributed content on different servers (conforming to the FHIR REST principles) * Provide different sets of documentation targeting relevant different audiences * Architectural overview for the architects, clinical overview for the clinicians, and implementation content for developers * Reuse common content in multiple implementation guides * Separate content from design/styling ### 2.5 Tools for writing IGs You can write Implementation Guides using Simplifier, the HL7 FHIR IG Publisher, and other tools. For writing IGs using Simplifier - see [blog post](https://thefhirplace.com/2016/08/08/create-my-first-fhir-implementation-guide-using-simplifier/), or watch our [feature movie](https://www.youtube.com/watch?v=aLQiDBxVXwM) on this topic. You can also use the [HL7 FHIR IG Publisher](http://wiki.hl7.org/index.php?title=IG_Publisher_DocumentationIG) - download it [here](https://www.hl7.org/fhir/org.hl7.fhir.igpublisher.jar). The [FHIR IG Framework]( http://wiki.hl7.org/index.php?title=FHIR_IG_Framework) defines a standardized framework around the IG Publisher that simplifies and compartmentalizes the work of IG publication. The IG Publisher is driven by the ImplementationGuide resource. The ImplementationGuide resource is a single resource that defines the logical content of the IG, along with the important entry pages into the publication, so that the logical package that the IG represents, so that the contents are computable. Forge has a feature for building the ImplementationGuide resource as well. ## 3. Validating your work Both Forge and Simplifier are linked to the .NET API. In Forge, your work is automatically validated against the API while you're editing. After uploading your profile to Simplifier, you can validate it using the ``Validate`` button in the top right menu of the ``Resource`` page. You may also validate your examples against your profile using the same ``Validate`` button, or just against the core specification. Another place were you can validate your XML or JSON code is the Validate tool: https://simplifier.net/validate. The [.NET GUI validator](http://docs.simplifier.net/fhirnetapi/) enables validation of FHIR XML or JSON against the specification (this includes custom profiles), supports terminology validation and serves both as a specification and a terminology server. Here below are links to videos explaining how to use Simplifier and the .NET GUI validator for validation: * [Validation with the .NET GUI validator](https://www.youtube.com/watch?v=p35Sw_T6jvc) * [Validation in Simplifier](https://www.youtube.com/watch?v=Vxqp_wdLpjM)