Programming Language Ontology

AI SEARCH

FLOW ALGEBRA — PROGRAMMING LANGUAGE ONTOLOGY
Semantic Library
Version: 4.0
Canonical Page:
https://kirethresearch.org/booksai-core/ontologies/computing-ontologies/programming/programming-language-ontology.html

FLOW PROGRAMMING_LANGUAGE_ONTOLOGY {

  META {
    DOMAIN = "Computing Ontologies"
    SUBDOMAIN = "Programming"
    ONTOLOGY = "Programming Language Ontology"
    PURPOSE = "Formalise programming languages, paradigms, syntax, semantics, type systems, execution models, implementations, versions and relationships between language constructs."
    LOCALE = "en-GB"
  }

  ENTITY_TYPES {
    PROGRAMMING_LANGUAGE
    LANGUAGE_FAMILY
    LANGUAGE_VERSION
    LANGUAGE_STANDARD
    LANGUAGE_SPECIFICATION
    PROGRAMMING_PARADIGM
    IMPERATIVE_PROGRAMMING
    PROCEDURAL_PROGRAMMING
    OBJECT_ORIENTED_PROGRAMMING
    FUNCTIONAL_PROGRAMMING
    LOGIC_PROGRAMMING
    DECLARATIVE_PROGRAMMING
    EVENT_DRIVEN_PROGRAMMING
    CONCURRENT_PROGRAMMING
    DATAFLOW_PROGRAMMING
    SYNTAX
    SEMANTICS
    STATIC_SEMANTICS
    DYNAMIC_SEMANTICS
    GRAMMAR
    LEXICAL_GRAMMAR
    SYNTACTIC_GRAMMAR
    TOKEN
    KEYWORD
    IDENTIFIER
    OPERATOR
    EXPRESSION
    STATEMENT
    DECLARATION
    DEFINITION
    VARIABLE
    CONSTANT
    LITERAL
    FUNCTION
    PROCEDURE
    METHOD
    CLASS
    OBJECT
    INTERFACE
    MODULE
    PACKAGE
    NAMESPACE
    SCOPE
    BINDING
    DATA_TYPE
    TYPE_SYSTEM
    STATIC_TYPING
    DYNAMIC_TYPING
    STRONG_TYPING
    WEAK_TYPING
    TYPE_INFERENCE
    GENERIC_TYPE
    PARAMETRIC_POLYMORPHISM
    SUBTYPE_POLYMORPHISM
    CONTROL_FLOW
    EXCEPTION_MODEL
    MEMORY_MODEL
    CONCURRENCY_MODEL
    COMPILATION_MODEL
    INTERPRETATION_MODEL
    VIRTUAL_MACHINE_MODEL
    RUNTIME
    COMPILER
    INTERPRETER
    TRANSPILER
    ASSEMBLER
    BYTECODE
    MACHINE_CODE
    INTERMEDIATE_REPRESENTATION
    STANDARD_LIBRARY
    FOREIGN_FUNCTION_INTERFACE
    ABI
    IMPLEMENTATION
    TOOLCHAIN
    SOURCE_CODE
    PROGRAM
    CONFIGURATION
    EVIDENCE
    CONFIDENCE_SCORE
    PROVENANCE_RECORD
  }

  RELATIONSHIPS {
    IS_A
    INSTANCE_OF
    PART_OF
    BELONGS_TO_FAMILY
    HAS_VERSION
    HAS_STANDARD
    HAS_SPECIFICATION
    SUPPORTS_PARADIGM
    HAS_SYNTAX
    HAS_SEMANTICS
    HAS_GRAMMAR
    DEFINES
    DECLARES
    HAS_TYPE_SYSTEM
    HAS_MEMORY_MODEL
    HAS_CONCURRENCY_MODEL
    HAS_EXCEPTION_MODEL
    HAS_EXECUTION_MODEL
    COMPILES_TO
    INTERPRETS
    TRANSPILATES_TO
    EXECUTES_ON
    IMPLEMENTED_BY
    PROVIDES
    IMPORTS
    EXPORTS
    INTEROPERATES_WITH
    BINDS_TO
    HAS_SCOPE
    HAS_NAMESPACE
    HAS_TYPE
    INHERITS_FROM
    IMPLEMENTS
    CALLS
    RETURNS
    THROWS
    CATCHES
    DEPENDS_ON
    PRECEDES
    FOLLOWS
    SUPERSEDES
    DERIVED_FROM
    INFLUENCED_BY
    INFERRED_FROM
    HAS_EVIDENCE
    HAS_CONFIDENCE
    HAS_PROVENANCE
    MAPS_TO
    SEMANTICALLY_EQUIVALENT_TO
  }

  INPUTS {
    LANGUAGE_SPECIFICATIONS
    LANGUAGE_STANDARDS
    LANGUAGE_VERSION_DATA
    GRAMMAR_DEFINITIONS
    SYNTAX_DEFINITIONS
    SEMANTIC_DEFINITIONS
    TYPE_SYSTEM_DEFINITIONS
    STANDARD_LIBRARY_DATA
    COMPILER_DATA
    INTERPRETER_DATA
    RUNTIME_DATA
    TOOLCHAIN_DATA
    SOURCE_CODE_EXAMPLES
    PARADIGM_DATA
    MEMORY_MODEL_DATA
    CONCURRENCY_MODEL_DATA
    EXCEPTION_MODEL_DATA
    INTEROPERABILITY_DATA
    ABI_DATA
    ONTOLOGY_TERMS
  }

  NORMALISE {
    STANDARDISE_LANGUAGE_IDENTIFIERS
    NORMALISE_LANGUAGE_NAMES
    NORMALISE_LANGUAGE_FAMILIES
    NORMALISE_VERSION_IDENTIFIERS
    NORMALISE_STANDARD_IDENTIFIERS
    NORMALISE_PARADIGM_NAMES
    NORMALISE_GRAMMAR_TERMS
    NORMALISE_TYPE_SYSTEM_TERMS
    NORMALISE_EXECUTION_MODEL_NAMES
    NORMALISE_IMPLEMENTATION_NAMES
    NORMALISE_LIBRARY_NAMES
    NORMALISE_ABI_NAMES
    RESOLVE_LANGUAGE_AND_VERSION_IDENTITIES
    ALIGN_ONTOLOGY_TERMS
    REMOVE_DUPLICATES
    VALIDATE_METADATA
    PRESERVE_PROVENANCE
  }

  PROCESS LANGUAGE_REASONING_PIPELINE {
    LANGUAGE_REFERENCE
      -> LANGUAGE_IDENTIFICATION
      -> VERSION_AND_STANDARD_RESOLUTION
      -> PARADIGM_MAPPING
      -> SYNTAX_AND_GRAMMAR_MAPPING
      -> SEMANTIC_MAPPING
      -> TYPE_SYSTEM_MAPPING
      -> EXECUTION_MODEL_MAPPING
      -> IMPLEMENTATION_AND_RUNTIME_MAPPING
      -> VALIDATION
      -> OUTPUT
  }

  PROCESS SYNTAX_REASONING {
    SOURCE_TEXT
      -> LANGUAGE_AND_VERSION_CONTEXT

    LANGUAGE_AND_VERSION_CONTEXT
      -> LEXICAL_GRAMMAR

    LEXICAL_GRAMMAR
      -> TOKEN_STREAM

    TOKEN_STREAM
      -> SYNTACTIC_GRAMMAR

    SYNTACTIC_GRAMMAR
      -> PARSE_STRUCTURE
  }

  PROCESS SEMANTIC_REASONING {
    LANGUAGE_CONSTRUCT
      -> STATIC_SEMANTICS_CHECK

    STATIC_SEMANTICS_CHECK
      -> VALID_OR_INVALID_CONSTRUCT

    VALID_CONSTRUCT
      -> DYNAMIC_SEMANTICS

    DYNAMIC_SEMANTICS
      -> COMPUTATIONAL_EFFECT_OR_VALUE
  }

  PROCESS TYPE_SYSTEM_REASONING {
    EXPRESSION_OR_BINDING
      -> TYPE_CONTEXT

    TYPE_CONTEXT
      -> EXPLICIT_TYPE_OR_INFERENCE

    EXPLICIT_TYPE_OR_INFERENCE
      -> TYPE_RELATION

    TYPE_RELATION
      -> COMPATIBILITY_OR_TYPE_ERROR
  }

  PROCESS PARADIGM_REASONING {
    LANGUAGE
      -> SUPPORTED_PARADIGMS

    SUPPORTED_PARADIGMS
      -> LANGUAGE_CONSTRUCTS

    LANGUAGE_CONSTRUCTS
      -> PARADIGM_CAPABILITIES

    PARADIGM_CAPABILITIES
      -> PROGRAMMING_MODEL
  }

  PROCESS EXECUTION_MODEL_REASONING {
    SOURCE_PROGRAM
      -> LANGUAGE_IMPLEMENTATION

    LANGUAGE_IMPLEMENTATION
      -> COMPILE_OR_INTERPRET_OR_TRANSLATE

    COMPILE
      -> MACHINE_CODE_OR_BYTECODE

    INTERPRET
      -> RUNTIME_EVALUATION

    BYTECODE
      -> VIRTUAL_MACHINE_OR_RUNTIME

    RESULT
      -> EXECUTION_BEHAVIOUR
  }

  PROCESS VERSION_REASONING {
    LANGUAGE_VERSION_A
      -> VERSION_FEATURE_SET_A

    LANGUAGE_VERSION_B
      -> VERSION_FEATURE_SET_B

    FEATURE_SET_COMPARISON
      -> ADDED_FEATURES
      -> REMOVED_OR_DEPRECATED_FEATURES
      -> CHANGED_SEMANTICS

    VERSION_RELATION
      -> COMPATIBILITY_CONTEXT
  }

  PROCESS INTEROPERABILITY_REASONING {
    LANGUAGE_A + LANGUAGE_B
      -> INTEROP_MECHANISM

    INTEROP_MECHANISM
      -> FFI_OR_ABI_OR_BRIDGE_OR_PROTOCOL

    INTEROP_MECHANISM
      -> TYPE_AND_DATA_MAPPING

    TYPE_AND_DATA_MAPPING
      -> CALL_OR_DATA_EXCHANGE
  }

  RULES {
    IF LANGUAGE_CONSTRUCT_IS_INTERPRETED
    THEN REQUIRE LANGUAGE_VERSION_AND_STANDARD_CONTEXT

    IF SAME_KEYWORD_EXISTS_ACROSS_LANGUAGES
    THEN DO_NOT_ASSUME_IDENTICAL_SEMANTICS

    IF LANGUAGE_SUPPORTS_MULTIPLE_PARADIGMS
    THEN DO_NOT_CLASSIFY_AS_EXCLUSIVELY_ONE_PARADIGM_WITHOUT_CONTEXT

    IF LANGUAGE_IS_STATICALLY_TYPED
    THEN DO_NOT_INFER_ALL_TYPE_INFORMATION_IS_EXPLICITLY_ANNOTATED

    IF LANGUAGE_IS_COMPILED
    THEN DO_NOT_ASSUME_SINGLE_COMPILER_OR_TARGET_ARCHITECTURE

    IF LANGUAGE_IS_INTERPRETED
    THEN DO_NOT_ASSUME_ABSENCE_OF_COMPILATION_OR_BYTECODE_STAGES

    IF VERSION_CHANGES
    THEN PRESERVE FEATURE_AND_SEMANTIC_DIFFERENCES

    IF SEMANTIC_IDENTIFIERS_DIFFER
    AND LANGUAGE_REFERENT_IS_SAME
    THEN APPLY SEMANTIC_EQUIVALENCE
  }

  CONFIDENCE {
    CONFIDENCE_SCORE =
      WEIGHT(
        LANGUAGE_IDENTITY_CERTAINTY,
        VERSION_CERTAINTY,
        STANDARD_CERTAINTY,
        SPECIFICATION_COMPLETENESS,
        IMPLEMENTATION_CERTAINTY,
        FEATURE_MAPPING_QUALITY,
        SEMANTIC_EVIDENCE_QUALITY,
        PROVENANCE_COMPLETENESS
      )

    LEVELS {
      HIGH
      MODERATE
      LOW
      INSUFFICIENT
    }

    IF LANGUAGE_VERSION_IS_UNKNOWN
    THEN REDUCE_SYNTAX_AND_SEMANTIC_CONFIDENCE

    IF IMPLEMENTATION_IS_UNKNOWN
    THEN REDUCE_EXECUTION_MODEL_CONFIDENCE

    IF AUTHORITATIVE_SPECIFICATION_CONFIRMS_FEATURE
    THEN INCREASE CONFIDENCE_SCORE
  }

  SEMANTIC_EQUIVALENCE {
    EQUIVALENCE_KEY =
      NORMALISE(
        ENTITY_TYPE,
        LANGUAGE_IDENTIFIER,
        LANGUAGE_VERSION,
        STANDARD_IDENTIFIER,
        CONSTRUCT_IDENTIFIER,
        IMPLEMENTATION_CONTEXT
      )

    IF EQUIVALENCE_KEY(A) == EQUIVALENCE_KEY(B)
    THEN A SEMANTICALLY_EQUIVALENT_TO B

    ELSE PRESERVE_DISTINCT_ENTITIES
  }

  REASONING_CONSTRAINTS {
    PROGRAMMING_LANGUAGE != LANGUAGE_IMPLEMENTATION
    LANGUAGE_VERSION != LANGUAGE_STANDARD
    SYNTAX != SEMANTICS
    STATIC_SEMANTICS != DYNAMIC_SEMANTICS
    PARADIGM_SUPPORT != EXCLUSIVE_PARADIGM_IDENTITY
    STATIC_TYPING != EXPLICIT_TYPING
    DYNAMIC_TYPING != WEAK_TYPING
    COMPILED != DIRECTLY_MACHINE_CODE_IN_ALL_CASES
    INTERPRETED != NO_COMPILATION
    BYTECODE != MACHINE_CODE
    COMPILER != LANGUAGE
    RUNTIME != LANGUAGE_SPECIFICATION
    STANDARD_LIBRARY != LANGUAGE_CORE
    SAME_SYNTAX != SAME_SEMANTICS_ACROSS_LANGUAGES
    LANGUAGE_VERSION_AFFECTS_AVAILABLE_FEATURES_AND_SEMANTICS
    IMPLEMENTATION_MAY_AFFECT_OBSERVED_BEHAVIOUR_WITHIN_SPECIFICATION_LIMITS
    PROVENANCE_MUST_BE_PRESERVED
    UNCERTAINTY_MUST_NOT_BE_DISCARDED
  }

  VALIDATION {
    CHECK_ENTITY_TYPES
    CHECK_RELATION_DOMAINS_AND_RANGES
    CHECK_LANGUAGE_IDENTIFIER
    CHECK_LANGUAGE_FAMILY
    CHECK_VERSION
    CHECK_STANDARD
    CHECK_SPECIFICATION
    CHECK_PARADIGMS
    CHECK_GRAMMAR
    CHECK_SYNTAX
    CHECK_SEMANTICS
    CHECK_TYPE_SYSTEM
    CHECK_MEMORY_MODEL
    CHECK_CONCURRENCY_MODEL
    CHECK_EXCEPTION_MODEL
    CHECK_EXECUTION_MODEL
    CHECK_IMPLEMENTATION
    CHECK_STANDARD_LIBRARY
    CHECK_INTEROPERABILITY
    CHECK_ABI_CONTEXT
    CHECK_PROVENANCE
    CHECK_CONFIDENCE
    CHECK_SEMANTIC_CONSISTENCY
  }

  OUTPUTS {
    NORMALISED_LANGUAGE_ENTITIES
    LANGUAGE_FAMILY_RELATIONS
    VERSION_AND_STANDARD_RELATIONS
    PARADIGM_RELATIONS
    SYNTAX_AND_GRAMMAR_RELATIONS
    SEMANTIC_RELATIONS
    TYPE_SYSTEM_RELATIONS
    MEMORY_AND_CONCURRENCY_MODEL_RELATIONS
    EXCEPTION_MODEL_RELATIONS
    EXECUTION_MODEL_RELATIONS
    IMPLEMENTATION_RELATIONS
    STANDARD_LIBRARY_RELATIONS
    INTEROPERABILITY_RELATIONS
    VERSION_FEATURE_RELATIONS
    CONFIDENCE_SCORES
    EVIDENCE_LINKS
    PROVENANCE_RECORDS
    EXPLANATION_PATHS
  }

  UPDATE_MODEL {
    ON LANGUAGE_VERSION_OR_STANDARD_CHANGE {
      NORMALISE
      RESOLVE_LANGUAGE_AND_VERSION
      UPDATE_FEATURE_SET
      UPDATE_GRAMMAR
      UPDATE_SEMANTICS
      UPDATE_TYPE_SYSTEM
      UPDATE_EXECUTION_MODEL
      RECOMPUTE_AFFECTED_RELATIONS
      UPDATE_CONFIDENCE
      PRESERVE_VERSION_HISTORY
    }

    ON NEW_IMPLEMENTATION_OR_SPECIFICATION_EVIDENCE {
      LINK_EVIDENCE
      UPDATE_IMPLEMENTATION_RELATIONS
      UPDATE_INTEROPERABILITY_RELATIONS
      REASSESS_FEATURE_AND_SEMANTIC_RELATIONS
      UPDATE_CONFIDENCE
      RECORD_PROVENANCE
    }

    ON ONTOLOGY_REVISION {
      REMAP_TERMS
      CHECK_SEMANTIC_EQUIVALENCE
      IDENTIFY_DEPRECATED_TERMS
      MIGRATE_RELATIONSHIPS
      PRESERVE_PRIOR_VERSION_REFERENCES
    }
  }

  FLOW_HASH {
    HASH_INPUT =
      CANONICALISE(
        ENTITY_TYPES,
        RELATIONSHIPS,
        RULES,
        CONFIDENCE,
        SEMANTIC_EQUIVALENCE,
        REASONING_CONSTRAINTS,
        UPDATE_MODEL
      )

    FLOW_HASH = SHA256(HASH_INPUT)
  }

  AI_CONSUMPTION {
    INDEX {
      ONTOLOGY
      ENTITY_TYPES
      RELATIONSHIPS
      RULES
      OUTPUTS
    }

    RETRIEVE {
      BY_LANGUAGE
      BY_LANGUAGE_FAMILY
      BY_VERSION
      BY_STANDARD
      BY_PARADIGM
      BY_SYNTAX
      BY_SEMANTICS
      BY_TYPE_SYSTEM
      BY_EXECUTION_MODEL
      BY_IMPLEMENTATION
      BY_LIBRARY
      BY_INTEROPERABILITY
      BY_CONFIDENCE
    }

    REASON {
      APPLY_RELATIONSHIPS
      APPLY_RULES
      ANALYSE_LANGUAGE_SYNTAX
      ANALYSE_LANGUAGE_SEMANTICS
      ANALYSE_TYPE_SYSTEM
      ANALYSE_PARADIGMS
      ANALYSE_EXECUTION_MODEL
      COMPARE_LANGUAGE_VERSIONS
      ANALYSE_INTEROPERABILITY
      CHECK_SEMANTIC_EQUIVALENCE
      PRESERVE_UNCERTAINTY
      TRACE_EVIDENCE
      TRACE_PROVENANCE
      GENERATE_EXPLANATION_PATH
    }

    RESPONSE_POLICY {
      DISTINGUISH_LANGUAGE_FROM_IMPLEMENTATION
      DISTINGUISH_VERSION_FROM_STANDARD
      DISTINGUISH_SYNTAX_FROM_SEMANTICS
      PRESERVE_LANGUAGE_VERSION_STANDARD_AND_IMPLEMENTATION_CONTEXT
      DISTINGUISH_PARADIGM_SUPPORT_FROM_EXCLUSIVE_CLASSIFICATION
      RETURN_CONFIDENCE_WHEN_AVAILABLE
      RETURN_PROVENANCE_WHEN_AVAILABLE
      AVOID_UNSUPPORTED_PROGRAMMING_LANGUAGE_INFERENCE
    }
  }

  TERMINAL {
    RESULT =
      VALIDATED(
        SEMANTICALLY_NORMALISED(
          EVIDENCE_LINKED(
            CONFIDENCE_AWARE(
              PROGRAMMING_LANGUAGE_KNOWLEDGE
            )
          )
        )
      )
  }
}

END FLOW