This documentation set is still under construction.

The table of contents (the "Contents" tree) gives an indication of the (intended) overall structure of the documentation - but it is by no means complete yet.

• Many pages are currently left blank (they may have a section label "A Topic Section") - these will be filled in later.

• There are no screen dumps (so far) - and too few figures. TOPICA was originally developed with danish user interface, and is currently in the process of being localized to other languages, including english. Screen dumps will be introduced once the localization to english language is completed (so that the language in the screen dumps matches the language of this documentation).

• The final documentation will contain information of the internal construction of TOPICA - .NET classes, properties, methods, etc. (i.e. the API) - auto generated from the source code and structured comments. This will be useful for application developers that want to use the TOPICA API (for extending the built-in functionality). This API documentation is currently only partly included (for technical reasons). Any references to API items that are currently not included, will display as GUIDs, e.g. [413210bc-f35c-4d8f-9fe6-5aec64b31797]).

TOPICA has evolved over the years, and is still evolving. This documentation covers several versions of TOPICA. In several places you will find mentions, that some features are only valid in some specific version.

Latest update: 2017-03-01.

The current version at the time of the latest update is TOPICA version 4.30.

Because the documentation is not complete, this does not mean that the documentation describes version 4.30 fully. It means, that the newest features described are from version 4.30.

Some chapters appear with a * in front of the title in the table of content. The * signals, that the chapter (the topic and all its sub-topics) is recently reworked and brought up to date.

TOPICA is a framework designed to facilitate developing clinical applications and modules.

• Framework implies:

  • A lot of standard functionality is built in. In TOPICA, this consists of functionality used in clinical applications for organization management, user administration, patient administration, security, logging, etc.

  • Many aspects of the system are configurable. In TOPICA this goes for input forms for clinical data (including rules), reports, etc. A key feature of TOPICA is, that the database structure is automatically generated to fit the configured forms. In this way it is possible to create a fully functional clinical database application without programming or performing database design.

  • The system is widely extensible. That is, the system may be extended in many ways by programming, if the built-in configurable options are not enough. This will be needed for example to develop integrations with external systems.

• Application in this context denotes a stand-alone end-user application, that handles everything (administering organization, users, patients, etc.). Such applications may have interfaces to other applications, but these interfaces are not necessary for the operation of the application.

  When developing stand-alone applications, you do not have to "re-invent the wheel" by implementing organization management, user management, patient management, security, accreditation, etc. - this is already implemented by the framework. Instead, you may focus on the clinical requirements for your particular application

  You may build an application from scratch. As long as the application uses just the standard functionality built into the framework, no programming is needed.

• Module denotes the situation, where TOPICA is used to design a module, that runs inside some other application (called "context manager"), that handles administering organization, users, patients, etc.). In this case TOPICA is used mainly for designing a some input forms (and maybe some reports).

  Getting a module to run in the context manager requires "front end integration" (handling the user interface, e.g. getting the "context manager" to launch the proper TOPICA modules(s)). In most case you will have to do some "back end integration" as well. That is, synchronize the data between the rest of the context manager application and the TOPICA database. See Integration.

Whether you develop applications or modules, TOPICA gives the following benefits:

• You do not have to implement the functionality, that is already built into the system: organization management, user administration, patient administration, security, logging, etc.

• Clinical data is entered by end users using forms, that are fully configurable. This mainly implies Working with Forms and The Structure File. You may use the built-in editor for this - or choose to edit the underlying XML files directly using any tool that may edit XML files.

  • TOPICA automatically constructs a physical data model (e.g. database tables, columns, etc.) from the form definition files (templates). This goes both for the initial data model and for any subsequent changes. I.e.: add a field in a form, and the system automatically adds a column to the database table - remove a field from a form, and the system automatically drops the corresponding column from the database table.

    Therefore, you do not have to concern yourself with building the data structure in the database.

  • Unlike some other clinical systems that have the functionality to dynamically define input forms, the physical data model generated by TOPICA is very close to the form definitions. The tables and columns are easily recognizable from the form definitions. The configurator decides table and column names. The general rule is: one form = 1 database table, 1 field (in the form) = 1 column (in the database table). Therefore, it is easy to extract data from the database for reports, exporting etc. (using SQL).

  • The system handles mapping of data between the database and the input forms. That is: the system generates input forms from the form definitions.

  • TOPICA comes with a simple but powerful built-in Domain Specific Language (named TOPICA Basic ), that enables the configurator to specify validation rules, computations of default values etc.

  • In summary: The configurator does not have to worry about generating detailed input forms in HTML, or getting the data in these forms persisted in the database by SQL. The configurator edits the form definitions, and the system automatically generates a physical data model AND a user interface to enter / edit data in this data model.

• Because of the ease by which a configurator may design / modify the input forms without coding (and alter database accordingly) TOPICA supports the following modern approaches to software development very well:

  • Agile software development and Rapid application development : The configurator may interact with the customer / end user to clarify requirements and rapidly build and deploy prototypes / updates for the customer / end user to evaluate and test.

  • DevOps and Continuous delivery : Getting new versions deployed from development to production environments is basically a matter of copying the configuration items from one environment to another. TOPICA comes with a built-in tool to facilitate configuration deployment.

• A described above, it is possible to build an application from scratch without having to write code. On the other hand, the framework provides many possibilities to extend the basic functionality (see Extensibility and/or Integration with external systems).

  To fully exploit all these possibilities, you will need varying levels of programming skills, but you will in most cases be able to build upon some functionality, that already exists in the framework.

This documentation set contains technical documentation related to TOPICA at all levels. Very few readers will need to read everything. What you need to read depends on your role.

Check the description of Roles to get an idea of which role(s) best describe you and how you are supposed to work with TOPICA. This in turn defines which subset of the documentation would be useful for you to read.

Having understood the roles involved in working with TOPICA, it is time for a deployer to set up the system, so that a configurator can start building (configuring) applications.

Refer to Getting Started.