TOP Software Technology

Task-Oriented Software Development

TOP stands for Task-Oriented Programming

Task-Oriented Programming enables us to focus on the description of the tasks that need to be done and the data that has to be exchanged between the parties involved.

From such a declarative description we are able to generate all software running on any server and any client (browser or IoT device). 

That is why we can focus on the real problems and develop reliable tailor-made systems much more easier.

When we develop a multi-user application for a certain domain with TOP, we search for answers to the following questions: 

How to present information and interaction to end-users?
Which data need to be shared?
Which tasks need to be done?
What are the domain specific notions and computations?
  • What are the domain specific notions (data), and operations on that data, that play a role in the particular domain for which the software is intended ? 

  • What is the work (the tasks)  people, software components, and computer systems have to do, and how are these tasks and the data they produce related

  • Which data needs to be shared between the workers while doing their tasks, who needs to see what, and when, and in which format 
  • What should the Graphical User Interfaces look like for each category of work?

In the TOP Tools we use, such as iTask and mTask, each of the questions above are defined separately as indicated in the diagram below:

GUI Specialisation (UI)
Shared Data Sources (SDS)
Task Definitions (WF)
Pure Functional Language (PFL)
  • As one can see, the Data Types play a central role.

    Algebraic Data Types (ADT), as can be found in pure functional programming languages (such as Clean and Haskell), are very suited to capture any domain specific data structure.

    These type definitions play a central role because they form the glue between all components.
    s furthermore guarantee that the data that is being used or exchanged will always be of the right format.

  • We use the pure and lazy functional programming language Clean developed at the Radboud University Nijmegen to describe the computations to be done.

    Clean is very suited for defining concise, reliable, modular, self-contained, highly reusable, software components.
    It considerably reduces the chance of making errors in the software and reduces the development time.

  • The tasks to perform are described in terms of subtasks. 

    One defines the order in which tasks have to be done, e.g. sequential, or in parallel.
    Unlike common workflow systems, also the data dependencies  between the work under execution are defined.
    The status of the work being done, the task value, can be shared with others and may affect the work others can see or do. 

    Virtually any way people and systems collaborate can be expressed in our system

  • We define which of the data, e.g. stored in databases, coming from sensors, or other data people work on or with, has to be shared with others, using Shared Data Sources (SDS's).

    By using an integrated publish-subscribe system, the (relevant part of the) shared data will automatically be communicated to the parties that needs the information, in a format they require.

  • Finally (!) we ensure that well-desgned Graphical User Interfaces are offered to the end users. 

    Most software designers take the user interface as a starting point when developing an application.
    But in our approach the work that needs to be done is leading.
    The user interface is not fixed, but is generated "at run-time", and its look and feel depends on the concrete tasks someone has to do at a certain point in time.

The way of working described above makes it possible for us to develop software for you which is very reliable, 
and simply works as intended.