What's Ontology of Programing Language?

if you don't understand something's ontology, you don't fully understand it.

a child “understands” car. But not sedan, coup, flying car, railcar, NASCAR, truck, van, bus, omnibus, automobile, transportation, jeep, motorcar, vehicle. You do.

let's pick something you don't understand. Say: analytic geometry, synthetic geometry, coordinate geometry, projective geometry, affine geometry, taxicab geometry, algebraic geometry, Euclidean geometry, elliptical geometry, differential geometry, complex geometry, discrete geometry, fractal geometry, computational geometry.

which of the above, are the same “category” with hierarchy? which are just synonyms? which are just informal term? which actually defines a particular math subject with axioms (as you would do a course of it in college)?

Now, you are like that child, who understands “car” the same way you do with “geometry”.

ontology, here, is the overall entities, their nature, relations, category, classification, the context with complete picture.

now, let's look at functional programing and object oriented programing. Wikipedia also lists the following:

    Agent-oriented
    Array-oriented
    Automata-based
    Concurrent computing
    Data-driven
    Declarative (contrast: Imperative)
        Constraint
            Constraint logic
                Concurrent constraint logic
        Dataflow
            Flow-based
            Cell-oriented (spreadsheets)
            Reactive
        Functional
            Functional logic
            Purely functional
        Logic
            Abductive logic
            Answer set
            Concurrent logic
            Functional logic
            Inductive logic
    Dynamic
    End-user programming
    Event-driven
        Service-oriented
        Time-driven
    Expression-oriented
    Feature-oriented
    Function-level (contrast: Value-level)
    Generic
    Imperative (contrast: Declarative)
        Literate
        Procedural
    Inductive programming
    Language-oriented
        Natural language programming
        Discipline-specific
        Domain-specific
        Grammar-oriented
            Dialecting
        Intentional
    Metaprogramming
        Automatic
        Reflective
            Attribute-oriented
        Homoiconic
        Template
            Policy-based
    Non-structured (contrast: Structured)
        Array
    Nondeterministic
    Parallel computing
        Process-oriented
    Point-free style
        Concatenative
    Semantic
    Structured (contrast: Non-structured)
        Block-structured
        Modular (contrast: Monolithic)
        Object-oriented (OOP)
            Class-based
            Concurrent
            Prototype-based
            By separation of concerns:
                Aspect-oriented
                Role-oriented
                Subject-oriented
        Recursive
    Value-level (contrast: Function-level)
    Probabilistic
    Concept

let's just look at a few terms: functional programing, object oriented programing, Probabilistic programing, Metaprogramming, Data-driven programing.

When approaching a subject, you might think, all these “xyz programing” is a big tree, of different types and subtypes, with respect to some criterions. But not really. Because, for example, {“parallel programing”, “meta programing”, “functional programing”}, are totally “different things”. You can have a “programing” that's all three. While, functional programing and object oriented programing are more like 2 things by one criterion, namely, a certain “style” of construction. Yet, can you really write out, exactly, context, the criterion, in simple plain english, that separates them apart? That's ontology. Also, as you know, some languages, such as ruby, are really both. Given a piece of source code, it can be said to be both functional programing and object oriented programing. So, here things gets critical. Repeat: can you, give a precise definition, context, judgement, that separates functional programing and object oriented programing apart? That's ontology. That's understanding. To fully understand it, you pretty much have to have a overview of most programing languages and history, and have a basic understanding of the programing field in practice, and theory of computability.

now, the main topic.

programing languages have “expressions”, “statements”. Do you know their ontology? what else are there in this category? what makes them whole, the context? which lang has what or not? what's each's effect? what necessitates them? what can be omitted?

PS there's also: directives, command, whitespace, comment, operator, keyword.