NESTS - Named Entities in Simple Tiered Spaces

Immediate/shorter-term development

Immediate

Effort is currently being focussed upon the completion of the following components:

  1. The NESTS core - a collection of Python3 functions implementing a very simple ad hoctree-structured DBMS built upon an Unix-type filesystem.

    These include functions for:

  2. A collection of Python3 functions implementing a CLI (Command Line Interface) of sufficient richness to support immediate testing, demonstration and experimentation.

    Initially, this CLI will comprise a set of operations sufficient for all open money requirements. In due course it will be extended to include a richer set of functions to support open measures requirements.

    This interface will not be suitable for most users' needs, but it is by far the easiest to implement, test and extend. It also provides a very useful scriptable API accessible via SSH.

  3. A collection of simple shell scripts to execute the CLI commands over SSH.

    These shell scripts are created per user and each contains a unique authentication code.

    Such shell scripts are themselves callable by other scripts, using a diversity of languages, allowing the rapid development of larger-scale structures.

  4. A simple Web interface implemented using Flask.

    For the majority of users, this will provide a more accessible and appealing interface.

  5. An OpenAPI-generated REST API (implemented using Flask or Falcon) to provide an alternative entry point where required.

    Currently this has a lower priority given that most shorter-term requirements can be met using the provisions above.

Longer-term development

  1. Complete OpenAPI-generated client libraries (Python and Rust initially).

  2. Develop a richer collection of reference clients.

  3. Design and develop simulation/modelling/visualization suite (ABS).

  4. Develop user feedback systems.

  5. Add further OpenAPI-generated client libraries (JavaScript and PHP initially?).


Dependencies within the immediate-/shorter-term development plan




A rough overview of the factorization

layer API abstraction functions significant extensions constraints
open money open money APIs open money rules The APIs at this level
constrain behaviour
to the open money rules.
open metrics open metrics APIs open metrics rules The APIs at this level
constrain behaviour
to the open metrics rules.
extended
open metrics
extended open metrics APIs open metrics
extended rules
Provides support for
compound data types
(vectors, matrices and
n-tuples), time series
and executable objects
(both direct/native and
indirect/referenced).
ledger/nesting
management
ledger management recursively nestable
ledgers management
Minimal constraints.
These layers represent
different sets/ranges
of capabilities, each
accessed via its own
collection of APIs.
Each layer may provide a set of APIs accessing its abstraction
functions, both remotely (REST or GraphQL) and locally (in some
cases simply by exposing the abstraction function set as native
package/library or by providing a set of bindings from one
language to another).

Additional components for open metrics implementation

Because the recursive namespace structure naturally mirrors the structure of a Unix-like filesystem, that is being used as the basis of this implementation, providing a quicker route to development of

The recursively-nested, holonic structure of the OM suite reflects the structure of the Viable System Model, so a suite of tools will be developed over time to support its application.



Version 0.2a - 2022-09-25 21:10 - Copyright © 2022, 2021 John Waters


home