Re: object system...


"Dmitry A. Kazakov" <mailbox@xxxxxxxxxxxxxxxxx> wrote in message
news:17h9c7ry176nh.1ruvqpvmfes0h$.dlg@xxxxxxxxxxxxx
On Sun, 18 Jan 2009 00:14:51 +1000, cr88192 wrote:

"Dmitry A. Kazakov" <mailbox@xxxxxxxxxxxxxxxxx> wrote in message
news:1qlpwnvjqzagv.1tk2ls4xkiveq.dlg@xxxxxxxxxxxxx

To put it simple, all extended logics have to be based on a
self-consistent
"normal" logic, where barber does not exist. The way they work is to
consider "exists Barber that shaves ..." as a formula. At some point
where
you wished to drop the quotation marks and *decide* if the barber indeed
does this or that, you land back into paradox. In fuzzy logic this is
called "defuzzification." Some things cannot be defuzzified, because
they
are, well, fuzzy. (:-))

The bottom line, you can reason about contradiction (=contradictory
data),
but you shall not reason contradictory. This the same story: data /=
program (behavior), subject /= object, set /= element, never reason
about
yourself...


I guess the next question is, WRT a program, what exactly is "self"
anyways?...

like, there is some piece of code or data that is unable to be processed,
and everything else is ok?...

Yep, this is exactly how the famous proof that halting problem is
undecidable goes:

while Halt (Self) loop
null;
end loop;

This is "self" that kills it. Any finite halting problem is decidable, but
you have to jump out of the box. Because only another program [with more
memory] can decide it. The same program cannot.


only that it is problematic to decide where "self" would be when it comes to
code.

a simplification though would allow that self be the current module and
everything interconnected with the workings of the current module.

of course, this allows a trivial solution:
any analysis of the current module can be done by another module.

the program as a whole is then capable of self-analysis, only that a given
module may not be...


but, in any case, the computer is its own self-reinforcing pattern,
already
well beyond the stage of a formally-defined system operating purely
on
input, output, and intermediate steps...

No. If all incomputable elements (clock, random generators, keyboard
input)
are considered as inputs, which they indeed are, then any computer
becomes
a finite state machine. It does not have either soul or free will.

Some (many) people belive that we too are finite state machines
agitated by
infinite inputs. So far nobody showed either.

well, issues of "soul" or "free will" are outside the scope of what I
am
considering (first one has to define what they are exactly, after
all...).

Infinite, hypercomputable etc.

ok...

well, I guess that is a bit different to how I was seeing things:
soul: very possibly a continued manifestation of a physical body
following
death, very possible wave-like and/or composed of some sort of "soul
matter"...

A belief of all educated SF readers... (:-)) But there is a mystery in
life
and intelligence, and an obvious mathematical inconsistence of the
evolution theory, etc. We should confess that we simply have no idea


yes, acceptable.


free will: ability to make decisions in such a way that one can be
credited
with having made decisions (and responsibility for these decisions). I am
not sure what exactly could give free will, only that I am fairly sure it
can't be manifested within a purely deterministic process...

Well, that depends. Determinism means that the new state is determined by
the old one. Now, the question is, whether the indeterminism is merely one
of an unknown input. So if you knew the input and the state you could
predict the next one. Or else it is the state itself that makes the next
one incomputable and thus unpredictable. The second is "free will", the
first is not. Further, there is the notion of computability involved. A
"hypercomputer" could compute truly random numbers (by generating an
infinite sequence of at once) , for such a system random variable output
is
decidable.


well, there is a property as I see it of deterministic vs non-deterministic
systems:
in a non-deterministic system, entropy (in the sense of the number of total
possible states) increases with time;
in a deterministic system, entropy either remains constant or declines.

so, in a non-deterministic system, each possible state leads to far more
possible output states than input states, and it may be sufficient to just
make transitions randomly and still get a consistent result.


in a deterministic system, each state leads to an equivalent number of
states, or less states, and so all transitions need to be deliberate in
order to make things work (so, in effect, entropy remains at equilibrium or
decreases).

similarly, it is not possible for a system to extend itself beyond its
original capabilities, or generate any "novel" results on its own.


one can, in a limited sense, faking non-determinism with a PRNG (or
equivalent), but this will have both a merit and a cost: given the same
inputs, the behavior of the program will always be the same. sometimes this
is desirable, and sometimes not. so, some problems require a TRNG in order
to work (examples: generating UUID/GUIDs, generating keys in some forms of
cryptology, ...).


the issue though is that a computer remains deterministic, but has long
since ceased being definable purely in terms of input, process, and
output.
FWIW, this notion breaks down much past the level of an Altair or early
mainframe.

as I see it, computers operate under cybernetic principles, where
pretty
much all of the computer-world operates in a sort of loop, and where
humans
have become partly an agent of this system. now, I am not saying this
in the
sense that humans have "physically" (or even really mentally) unified
with
the machines, only that, at this point, no machine is built or operated
purely independent of other machines (both hardware-wise and
software-wise),
activities by one person on one machine (or by the machines themselves)
influence later actions by other people using other machines, a kind of
machine-world "ecosystem" exists (even if in the form of continuous
activity
by humans, ...), ...

No, this is untrue, because we still design and program our computers in
isolation of their "human subsystem."

but, the actual creation part can no longer be done apart from
machines...

They are mere instruments. And we know how in theory to start it from the
square one. This is a crucial important point. It allows us, for instance,
creation computing system based on any switching medium. Mechanical,
optical computers. I remember a paper that shown that a computer can be
built using Conway's life gliders.


yes, potentially. but how do we do so? by using the existing stuff...


the "actual" task would be, allowing people to retain all of their knowledge
and information, to be promptly returned to the stone age, and have them
recreate it all before they forget...

if the physical side of the modern world were all taken away, people would
likely have returned almost completely to a state-appropriate civilization
within a few generations. new generations would simply feel no need to learn
these huge amounts of esoteria, as they battle with more pressing issues
like how to find food, defend themselves from preditors and enemies, and
build shelter for themselves...

assuming accurate knowlege retention and a stable society, it is possible
though that industrialization could be achieved within maybe 500 or 1000
years though, which would be much faster than humanity has progressed thus
far (since, hell, humanity would start out knowing physics and calculus,
they will just lack the ability to make many of the fundamentals of modern
society, such as metal, concrete, glass, ... and will have to re-establish
how to go about producing it all...).

much more likely though, nearly complete forgetting would occure, making the
process take a good deal longer.


consider, for example, Rome.

Rome had many technologies that, when the empire degraded, were lost for a
very long time, such as the ability to make concrete (and, more so, some
Roman buildings were steel-reinforced concrete...), ...


in the past, humans were the primary means of information storage and
processing. any information that was to be stored, was stored by humans
in a
human accessible for (human memory, scrolls, codexes, books, ...), all
information processing was done manually (and primarily via human
mental
faculties), and likewise, any human creation was done by a human
themselves,
and by tools made through human effort.

so, for example, one person is a blacksmith, and they make hammers and
chisels, and these are sold to a craftsman, who carves wood or chisels
stone. in part, it is the hammer and chisel that does the work, but
they are
weilded by the person, and going back one step (to the blacksmith),
they are
a product of human effort.

Yes, a system computer-human [possibly] has different properties. BUT,
we
do not program that system. You make a logical error talking about
programming and programs referring to the larger system. It is as if you
talked about astrophysics being progrmmed because computers (and we)
consist out of burned out star material.

matter is, however, a substrate.
since it is well established that humans can't live (or exist) apart from
matter, it is not necessary to consider it.

You make it dependent on the issue of physical existence which itself
cannot be consistently reasoned about being physically existing...


technology and information is not too much different than matter as I see
it...
granted, there are minor differences in the rules, but the basic properties
remain consistent.

a world built out of data could quickly begin to resemble one built out of
matter in many ways...


more so, raw matter does not exhibit any kind of cybernetic (or, AKA:
homeostatic) properties...

No, AFAIK there are many living and also dead natural homeostates. But I
doubt that cybernetics is really about homeostasis. It was a simplified
view of early 50's, IMO.


commonly they are associated, with "cybernetic" AFAIK refering to a system
being able to respond to the environment in order to maintain a state of
homeostasis.


as I see it, modern technology is currently in a gray area between that
of
inanimate objects, and that of being animate (or, as it could be said
another way, "living"). however, as I see it, they still have a long way
to
go...

It would be nice if it were so. But in my view the margin is still hard.
So
far nobody managed to create anything close to the behavior of a fly or
ant.


yes, but this demands a view that such "informational life" would need to in
some way emulate that of "organic life". if such a state were to be
achieved, they would be sufficiently different as to be almost unable to
recognize each other as such...

of course, I still have some reservations as to whether such a state would
be a good thing.

some people promote the idea of "the singularity", where personally I find
the whole idea a little scary, in part because such a state would cease to
be under human control, and so just what would happen would be neither
known, nor likely could any consequences be avoided.


so, there is a good point to machines remaining stupid and predictable as
well...
people can continue making them as ever better tools, but should likely
continue to retain their role as tools (and not placed in the role of some
kind of deity, as many of the singularity supporters seem to do...).


There is a fundamental principle that a logical system cannot reason
about itself. So any proposition like exists (self) as well as not
esits (self)
is automatically either inconsistent or undecidable. It is a wonder
how
humans managed to do this stuff all the time in the history of
pilosophy... (:-))

well, I am not sure the basis of the above claim (that a system is
unable
to reason about itself).

You can see your hand when it is at a distance from your eyes. But you
cannot see your head.

a mirror is sufficient to see my head...

Mirror produces a model of your head. Now you cannot see yourself
looking
at the mirror...

I see my head as it looks at the mirror...

You see your head-in-the-mirror. You don't see your head, only a
reflection
of. You deduce "head" from the reflection. And even if this deduction were
equivalent to the head, which is not, you needed another part of the
equation, the mirror itself. You do not see that mirror, only a reflection
of you in it. The system as a whole: "me looking at the mirror" is not
observed. To do it, you would have to install a second mirror somewhat
above to see you, the first mirror and your reflection in it. But then
again the whole system would be "me looking at two mirrors," etc.


oh, ok...

I think I know what you are getting at now...

but, alas, complete understanding of the "whole" problem is not necessary to
accomplish my tasks...
alas, even as a human, I tend not to consider the entirety of a program at
the same time, but tend to carve it up in more or less the same way I
organize my code. this way, I see the external interface and defined
behaviors, but when considering a particular component, my scope of thinking
does not extend much outside this component...

and, then when later considering another part using the component, usually
another component will reduce simply to its external interface and behaviors
(the innards of the component may become mentally invisible, basically in my
mind it reduces simply to a set of function calls represented as some kind
of "mental tokens").

in part though this is because I lack the mental capacity to keep the
entirety of a several-hundred-kloc project in-mind at once...

I don't expect a compiler to do too much differently, as it has its area of
responsibilities, and it performs the tasks it is given with the information
it is given...


a recent example (or, partial consequence) of this was going and ending up
partly having to reverse enginneer and document one of my own pieces of
code, simply because I had managed to largely forget how it worked, even
though this component plays a fairly central role in my codebase... (I also
went and looked at prior projects to trace back this component to its
earlier forms, finding it to have had its origins back in 2002, and mutating
into its present form in successive steps over the years...).

and all for what purpose?... I needed to add a few features...


actually, ammusingly, it lost a feature back in 2004 or so, only to have it
re-implemented around 2007 in an almost completely different way...

and, these new features that were added?... ammusingly enough, a feature to
allow it to, as an extension, be used in more or less the same way its
original form was used back in 2002 (in 2004 its role and operation having
been changed somewhat, and its subsequent mutation path somewhat deviating
from its original form).

and, oddly, it took me a good deal of effort to re-remember all of this
stuff, which was then written into my running rev-eng spec...


Reasoning about self, at full, means that there is a model of self.
Does
that model includes the model itself? A model of model? And so on.

so, do you think a homunculus necessarily exists?...

I don't know it. See above. Human brain contains incomputable elements.
Whether their role is trivial (inputs) or not, I cannot tell.

ok.

well, personally I don't believe something equivalent to a homunculus
exists, because that would make a problem:
how could this exist without itself containing a homunculus...

this would keep going on either infinitely, or maybe there is a
homunculus
with the one inside it being itself (AKA: it itself is shaped sort of
like
out good old friend the klein bottle...).

I think Leibniz had the idea that this was a kind of "monad", but then
there
is a problem: as I see it, no kind of monadic entity would have
sufficient
state to retain properties like conscious identity, ...


a simpler idea is to assert that no such entity exists, and that "self"
is
more of an emergent property (I would seem to exist, but no single part
of
myself is "myself" as such, ...).

if you take a person and hack them apart, you don't have a "trimmed down"
person and a bunch of spare parts, all you have is the parts...
(although,
presuming they are dead, one can say that the "self" part of them flies
away
at death, but oh well...).

What happens if someone created an identical copy of an individual on a
computable medium? Incomputable elements prevent this. however, you can
construct some of them, but not identical copies. Some physical processes
allow synchronization of some random processes. We know too little...


well, if a person can be copied exactly, what the exact result would be (as
well as the "identity" issue) is a bit of a mystery...

if I were copied and were the copy, I would probably regard my identity as
separate from the original and probably add an extended middle name to
identify my revised form though (could be some conflict over first name
though, as for me it is really awkward to be near someone else with the
same, or similar, first name...).

I am not sure what exactly collaboration or general interaction would be
like with a copy of myself though (I suspect I might get annoyed some with
tendencies towards verbosity, ...).


speaking of nonsense... I recently beat together a textual analyzer and
generator based on a 'Hidden Markov Model'... it generates text that in
some
cases almost makes sense, even if it is all just a big set of associative
graphs and random walking to produce the text (AKA: there is no
"understanding" in the system...).

but, alas, an HMM is something which is far from being complete, but can
still get "useful" work done...

Yes, to close outputs to inputs of a learning system to see what happens.
In many cases it can be predicted. If the system is more or less linear,
there will be nothing interesting, otherwise...


the question then is how effectively it can be put into practical use, and
for what sorts of tasks...


if it works, it works...

No, it does not. The answer depends on whether "it works" is decidable
in
the logical system used. And it is not. So you don't know if this
statement is true. It is merely a belief.

that things like foundational arithmetic have some rather gaping holes in
them does not prevent the convinient use of counting, or the
implementation
of ALUs...

nothing stops a monkey from learning to pick locks either, even if it is
possibly the case that the monkey will be able to fully understand or
reason
about the locking mechanism...

that something works is sufficient grounds to make use of it, even if the
logic behind it seems to be incomplete or broken...

Pragmatically yes, but monkey never made it to the Moon...


as I see it, human thinking still approaches problems in a similar way, just
humans are a lot better and so can consider more information at the same
time, than can a monkey...

and, the monkey is a good deal more powerful than a mouse or hamster (as
many primates can figure out simple tool use, ...).


this is in contrast apparently to regarding the computer in its own
right,
and considering the relation between the user and computer (or the
computer
and reality) as much more bidirectional (like, the computer and the
software
world already exist, I more interact with it and try to work on it
and make
things better...).

OK, but that is not programming. If the computer reality already
exists
(like in a computer game, or less exciting, like in an office
package), you
do not program it. You simply interact the reality. It is the
difference
between programmer and user. User is a subject of reality. Programmer
creates realities.

the programmer does both. they write code within the existing computer
reality...

You mean "human" here. Programmer is a role. It is not both. A human can
play different roles at once.

maybe, but it does not mean they are not a programmer if they operate
within
the confined of reality...

As I said, I use computer to as a press...


I don't know the purpose of this statement...


But it is all economic in the end. A technology that is not economically
feasible cannot sustain for a considerable time, even if you managed to
pay
others for it, as in the case of software products. That only agravates
the
problem, because the real expenses are invisible. We already had the IT
buble. But the software buble is much bigger...

hmm... commercial software blows up and everyone uses opensource...

Freeware you mean? I think that it was an answer to the broken commercial
model. But freeware cannot sustain either. You need to reward and select
people developing software, in a way that makes software better. Freeware
lacks this mechanism either and the quality of is as miserable as the
quality of commercial software.


it all goes on though...

people continue writing software, gradually fixing limitations, and
selecting for better code. changes made in one project may also propagate to
other projects, ...

so, code is made, code is copied, and code dies...
better code and technologies survive and weaker ones die off, and eventually
software as a whole improves...

although a big cost is that systems may lack modularity, meaning that it may
be difficult for changes to propagate effectively when code is duplicated,
but the desire to keep things up to date (leveraging on others' work, ...)
leads to huge and elaborate masses of dependencies. very often making
software very difficult to build or make work much outside its original
context (a simple example is just how painful it can be trying to make most
Linux-based software run on Windows, ...).

standardization can somewhat help here as it can allow breaking apart these
hugely complicated dependency trees, allowing code to be ported to another
OS, not because "the library" is written with all these different OS'es and
archs in mind, but rather because alternate implementations can be provided
(or, even used on the same OS if the need arises...).

so, it is my opinion that each shared library should specify an API which is
independent of the implementation, and that the possibility of multiple
implementations should be assumed and designed into the API, and more so,
any version numbers should be associated with the API, and not with the
library (although the library may have a separate set of version numbers
than that of the API). likewise, an app should be willing to tolerate the
existence of older versions of the API, and try to operate within the
confines of the API that is provided (rather than doing like many opensource
projects and refusing to build until the user downloads and tries to build a
newer version of the library, which may demand newer versions of other
depended-on libraries, ...).

and more so, if an app does need to use an API of this sort
(non-standardized, ...), it should be wrapped up such that it can be
emulated on the new arch (meaning, for example, that only certain kinds of
functionality should be depended on, ...). porting may then involve writing
a new implementation of this library.

as an interesting consequence, this puts me in almost exactly the opposite
category of projects which use the likes of things like SDL and GLib...


open-source then becomes a sort of massive feedback loop, which even if
lacking resources and much to prompt programmers to make good code or fix
things, eventually competes with commercial efforts (which are good at
achieving things quickly, but tend to produce sand castles which quickly
become eroded by the waves...).

the big problem with the commercial approach is related to reuse, where each
company produces masses of resources "in house", but these resources die
with the project. next project, bunches of new resources, and the old sand
castle is left to fall into oblivion...

and, other companies?...
they either have to liscense components and resources, or build it all
themselves, and then it all falls into disuse after the release of the "next
big hing"...

the only reason any real long term improvement is made is because each
company works at improving their particular component to compete with
everyone else, thus gradually improving the quality of the "substrate" as
well...

and so, each new time, someone comes along and builds a new sand castle,
each a little higher than the last...

yet, the structure rests solidly on the continued operation (via profits,
....) of the companies which maintain these components (and so, we can sure
as hell hope there is at least 2 or more independent companies producing
each kind of component...).

thus, the need for standardization becomes critical as a means to help avoid
vendor lock-in, ...


but, both approaches have both good and bad points...


--
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de


.

Relevant Pages

  • Re: Which Is Better?
    ... The reason they gave was from a DBA perpspective like it was ... MERGE really necessary here - do you do any inserts in that loop, ... statistics for both approaches and compare them to see what could ... Did you capture any other statistics aside from run time ...
    (comp.databases.oracle.misc)
  • Re: measuring clock cycles per second
    ... In fact, I am not trying to convince you, I'm trying to find a reason why you would think it's useless. ... Let's assume that a program only executes a single loop and this loop ... Even if the average execution time of #1 is exactly 1/4 of the sampling interval and the average execution time of #2 is exactly 3/4 of the sampling interval, then, provided the standard deviation of the respective probability distributions of times is nonzero, the total time taken by the loop will, in general, be unequal to the sampling interval, even if by a mere 1%. ... Rather than the poor resolution, I find the fact that measurement itself leads to changes in timing more difficult to work with, especially when -g is used (not sure about the reason). ...
    (comp.os.linux.development.apps)
  • Re: Need Thread Advice
    ... The event object concept seems more reasonable. ... The code is written so that when a button is clicked, I open a com port ... but the release code hung in the whileloop. ... reason for this is volatile typically does not have the correct memory ...
    (microsoft.public.vc.mfc)
  • Re: excuse me if this is a real noddy question ...
    ... this is not the obvious reason to which I was alluding, but again, I could ... heap space is found and allocated for an object of size __sizeof ... made outside the loop, heap space is only allocated once, and the object is ... I would declare my pointer OUTSIDE of the for loop (for ...
    (microsoft.public.dotnet.languages.csharp)
  • Re: Correct C++ tutorial part 3 "Intro to loops" available (Windows, mingw/msvc/std)
    ... >> see no reason told for this statement. ... Why would a floating point type misleading if I need a floating point value? ... do you need a floating point iteration or not? ... > loop control variables. ...
    (comp.lang.cpp)