Representation of an object in programming. - page 6

New comment
 

And so, Object. (Let's be trivial and take the same Rectangular Label.)

1) BasicObject Components:

We all know these building blocks, so there's no point in being intrigued by them. More or less complicated object has:

  • Parameters are the most basic group of constituents, but not the simplest. In my opinion, the most accessible explanation of a Parameter, is an entity representing some named set or value in the structure of a system or environment. The Parameter succinctly conveys a set through its number and is part of the constructor functions which reproduce these structures. Although it is not the only type of parameter, we will focus on it for now.
  • The set of properties is a complex of parameters, which unites"object-metrics" data used by different functions - i.e.key-values and complex structural sets of Object. In this example, the Label has 5 parameters - x,y, (position in space), width, height (width and height), colour (colour), i.e. the set of its initial properties begins, but is not limited to input parameters (arguments) of the function that represents it.
  • The constructorfunction is a set of actions (aka algorithm) that reproduces the object. The function drawing the Label uses all of the above parameters in its execution. (It should be noted that the basic set of parameters of the Label is determined by the implementation method of the function - constructor. If we change the method of drawing the Label (for example, drawing it with one cycle instead of two), the initial set of Label parameters will also change).
  • Form - it's hard to deny that all the examples of objects you can think of have a form. The form of a Label is primitively simple, but it is an inseparable part of it. However, there are objects which have no form and hence it is not an essential component of an Object. Form is an important part of "life" and can transmit a flow of information through it - as events, processes, states, trends, etc.
  • States are meaningful"breakpoints" in the Object's being. In coder terms - values of parameters of the object, to which it passes when the conditions of the external environment change, or in the process of independent execution of the internal programme. They are present at any, even minimally complex systems. This attribute transforms a simple Label into a system and requires us to formalize the logic of transitions with a set of additional conditions. At the same time, a parameter set of a Label may still be primitively simple, but addition of States increases the number of possible parameter values, forcing to allocate additional memory for them, and the Label changes the status of a primitively simple object toa functional system,as in addition to its constructor it has acquired the additional function of switching states.States are inherent in more complex objects that comprise various systems.
  • Events are an attribute of the Object of even higher level of complexity. Having only States, the Object (Tag) can resemble a simple clockwork that changes the values of its Designer Function parameters in a preset sequence and its entire "life" is limited to a single chain of preset States, however the addition of Events breaks this chain and introduces new transition sequences, finally integrating into the Tag (Object) a more complex system of behaviour or interaction with its Environ. But more on this later, let's move on to the definition ofan Event and its software implementation.

An Event is a meaningful change to either the object itself or its environment. Structurally, the Event may include a description or indication of the background state of its object (the tag) which is the condition of the change occurring, but its main task of describing the Event is to communicate what has happened to the tag, or to the system integrating it, or to the external Environment of thechange itself, which can be expressed through the specific values of certain (initial or derived) parameters, through the relations of some values present in the System or the Tag Environment, or through the construction of the nature (signature) of the change if it itself has changed. All this can be seen as an Event. *Later on, I'll come back to the question of the programmatic description of the object components.

  • Processes are the next level of complexity. If we look back for a moment, we can see how each subsequent object constituent not only becomes more complex, but also includes the previous one as an" add-on": Parameters describe structured sets, Object properties combine selected parameters into a complex, Constructor function combines sets of object parameters, States can combine both sets of parameters and forms. Events can combine states to describe the background against which a meaningful change occurred, followed by Processes.

Processes merge States and Events of an Object into a sequence, which can be represented as a "chain" or "series" of values of a selected set of parameters of the Object ordered in a certain direction. The best analogy would be a numerical series, where the values in the cells are conditioned by a Process, which can be either random or planned. However, the Process itself consists of many such numerical rows, where each is assigned to a parameter. Creating a Process is easy - just take an initial set of parameters (e.g. a constructor function) and generate (or get) a series of values for each of them. It's also easy to decompose the Process into States, Events and Transitions between them. They can be broken down into parts and hierarchies, linking the parts by arbitrary or predefined sequences. What's important is that you can "break" the Process into its components or assemble it from them. Processes can be modelled, optimised and modified. Processes are present both within the objects themselves and in the object environment. In this case, the Environment acts as a "Meta-Object".

It must be added here that a Process, however complex it may seem, is merely a sequence of parameter values combined into Event and State formulations, which in turn are constructed based on the initial set of parameters that describe the Object structure and are used by its constructor function (or else by functions that implement the Object's life).

This concludes part one. In the second part, I will continue proceeding to the next levels of complexity of the Object, considering the Event and Logical Models of the System, their constituents and the principles of their construction.

In the third part, I will move from philosophical formulations to questions of new implementation of software Objects and code (although this will not be easy).

 
Реter Konow #:

Very interesting questions you pose.

1. it is indisputable that our speech (or any other form of statement of thought) is physically linear because it unfolds in time, but Thinking has not only a physical dimension, but also a logical one, and can be both linear and dialectical in terms of its logic. Well, for example, the fact that I purposely went back to the origins of OOP (while humanity in its mass is linear), is an example of logical non-linearity of thought, while the linearity that you speak of, is only a generally accepted order. Thought breaks it all the time by going "back and forth". Just try to prove a theorem without taking steps backwards and rethinking your actions first).

I agree that one can jump from one logical branch to another through intuition and erudition, not like the formal ATP SPASS/HOL/NuPRL/etc proof systems, but even such "back and forth" jumps are linear and (theoretically) algorithmizable, for example if one imagines that one can make pseudorandom assumptions in some framework and prove them formally again.

One can recall the de Bruijn principle: a system is built of 2 parts - a compact formal logical kernel-verifier - does what all ATPs do, and next to it, something as big as possible, that can cling to exogenous data (intuition, shamanistic songs, posts from mql5 forum...).

So even in this case we get a linear system, because the algorithm is sequential and fits in Turing... I may be using terms too loosely, but I'm forgiven, I'm a humanitarian, if anything respectable mathematicians can correct me...

Perhaps we need not only a nondeterministic potential infinite automaton, but also an automaton capable of performing many asynchronous operations simultaneously.

As a fun, you can recall MathGen project for generating random mathematical texts:https://thatsmathematics.com/mathgen/.


2. I agree with the theory of limitation of human ability to understand and perceive the World. It is not so difficult to find one's limits. For example, a human cannot reach and process large sets, cannot predict dynamic chaos with high entropy and so on... But, how much does he need it? Man creates technologies that successfully extend his ability to "encompass existentiality with his universals". Kant, I think, said nothing about this).

There is no limit of perfection, but mathematics can strike from an unexpected side, for example here you create a model of meta-objects, and at some moment (say, after 50 years of hard work, hehe) you needed a self-verifying automata, and Gödel jumped out and said: - no way! - In any formal axiomatic system with predicates above the second level [if I am not mistaken] one will always find formally true, but not-proof and not-refutable statements, and what to do? - Go back to the factory?

Interestingly, some cryptocurrency projects claim to achieve Turing completeness, and even here they may be deceiving, purely as a marketing ploy, the Ether platform in particular is claimed to be Turing-complete, and Bitcoin for example is on the contrary known by design to be incomplete Turing, but has anyone actually checked this, that is the question, and to what limits is this true...


3. You've mentioned concepts like "hyper-objects" and "meta-objects" several times in various places. Just on this topic I wanted to speak in my next post and disclose the content of Object in my concept, where "Meta-Objects" among others are present.

I should add that the concept was built as programming-oriented as possible, since the ultimate goal is to create a new AI engine, so all explanations and examples will be coder-oriented.

Hyper-objects I used following Timothy Morton, in his interpretation, are such objects which are so massively distributed in time and space and which transcend a particular localisation, and here it is interesting to note that this is the area where mathematics and technical science begin to touch art, myth and magic... The confidants are well aware, for example, of the concept of hyper-sigils in forbidden rituals of chaos magic, it is a way of complex influence on reality, although what is published on the subject is usually shrouded in a thick veil of the blackest obscurantism and sinister Satanism, but if we discard it, then we are left with the principle of complex influence including informational influence on an object/subject capable of receiving this information, something similar to hybrid warfare in modern geopolitics or decentralized protests, and the meta-object can probably be considered a generalization of the hyper-object to a non-local extratemporal but still identifiable process, almost something like an archetype.

 
As I said yesterday, it's going to be a hot topic again, started in 19, now it's getting hot again.
 
Реter Konow #:

And so, Object.

Write it down immediately in Backus-Naur form. It will be possible to check for consistency and isomorphism of already existing variants.

 

This is all very important for trading!

Down with the glut of context-sensitive formal grammars!

 
Aleksey Nikolayev #:

Write it down at once in Beckus-Naur form. It will be possible to check for consistency and isomorphism to already existing variants.

Show an example, please.

 
transcendreamer #:

This is all very important for trading!

Down with the dominance of context-dependent formal grammars!

I think you can think of prices as a context-dependent stochastic grammar.)

 
Aleksey Nikolayev #:

I think you could think of prices as context-dependent stochastic grammar.)

Um... Maybe then wave sequences with probabilistic rules like: if there was such-and-such an observed sequence of terms/signatures WXYZ, then further maybe ABC, ABC, BAC, ABC, CAB, CBA with some probabilities whose vector would point to the Grail in probabilistic space. 😁

 
Aleksey Nikolayev #:

I think prices can be thought of as a context-dependent stochastic grammar.)

But it's a Markovian model at the core, which obviously doesn't take into account dependence on market background, does it?

 
Реter Konow #:

Show an example, please.

Whole numbers and comma separated list of integers (the list can be empty)

<digit> ::= "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"

<integer> ::= <digit>|<integer><digit>

<list> ::= <""> | <integer><","> <list>

12345678910111213...17
New comment