in particular, the parts related to:
having a shell, VFS paths like '/bin' and '/dev', ability to invoke tools,
...
support for running multiple processes (within the context of a host app,
thus having a reason for certain calls, such as 'fork', 'execl', 'pipe',
...);
...

as I am thinking of it, in this case the 'kernel' would operate primarily at
the 'native' level (though, potentially, portions of such a kernel could
sensibly exist within the simulated world, but this is not currently being
provided for, as such...).

in this case, tools such as 'sh', 'cc', 'ld', ... could be provided, but
would likely redirect to functionality provided in the host app / VM (the
command interpreter and compiler existing as native code, ...). tools like
'ls', 'grep', ... if provided, would likely exist within the VM.

(I am starting looking into the possibility of using some of the BSD
codebase, potentially, as parts of the simulated world).

or, is all this more just sort of insane and totally out of place in a
VM?...

(granted, this at least does partly address the standing mystery of where to
best put the include VM files and libs...).

ammusingly, it seems my VFS is already mostly POSIX-like, having been a
subsystem which has (more or less) survived from my original OS project
(although, it has been rewritten since then, but kept the same basic API and
design...).

note that in this model, it is still assumed that any facilities, such as
GUI, will be provided by the host app. (I am currently imagining supporting
OpenGL bindings, as well as probably a yet-to-be-designed GUI toolkit).

for the GUI toolkit, I am partly imagining combining aspects of GTK, GDI,
and AWT.
particularly:
it would be based on opaque handles and API calls;
widgets are created as mostly-opaque objects which are added to 'boxes'
(hbox, vbox, ...).

this would then be redirected to a GUI backend presumably running in native
code.

I might also provide direct bindings to my object system (I call it
dyClass), but this does not look like a 'fun' experience.

partly due to having around, at present ~600 API calls related to basic
object operations (and the realization that, oh crap, I wrote the code
behind all of these API calls, yet a simple JNI-like wrapper seems terrible,
oh well...).

then again, I can also note that I have > 2x the number of API calls as
JNI...

(I don't really want to try to write code for mapping this many API calls
across address-space boundaries, almost may as well just try to map JNI and
live with a 'functional subset'...).

that or I make use of a mechanism with a vague similarity to 'P/Invoke'
(basically, a big wrapper lib makes use of a syscall which attempts to
auto-marshall its arguments and invoke a native function).
the strategy in this case would then be mostly to try to make this interface
solid.

but, alas, I am loosing focus here...

What is the main need for your interpreter/VM?

so, in a way, it is similar to where many other apps would use something
like JavaScript or Python...

but, in the long course of implementing things over the years, it has ended
up being a much "weirder" piece of technology than a typical VM...

basically, back around 1999-2004, I had wrote an OS (which also operated in
userspace to make it easier to debug).

at the time, the reason for the 'demise' of OS-related efforts was because,
at the time, it was starting to look too much like a hybrid of Windows and
Linux, and I figured that the results would not be worthwhile vs these
existing OS'es. at the time, it got to the level of supporting PE/COFF based
binaries, processes, a simplistic GUI, as well as a basic HTTP server, ...
(I had also tried porting NASM to the thing, but it didn't work right as my
C library was just sort of hacked together and so was unusably buggy...).

but eventually this OS ended up migrating purely to userspace (and ceased
being an OS...), and had a run-in with the Quake engine (forming, for a
time, a sort of conglomerate entity), and was internally very unstable
(parts shifted around a whole lot, many parts broke and fell away, ...).

in particular, it ended up loosing its drivers, support for a 'userspace'
(this part only worked while running on raw HW), its internal TCP/IP stack,
...

it kept the VFS and many other parts, which had partly assimilated with
and/or replaced the Quake1 parts.

following this, the Quake1 derived parts started being removed and replaced
(the Q1 codebase was very brittle, and I was unable to keep it from breaking
apart, and found I was unable to fix the parts which broke...). I was never
again able to get the project to be a fully functional 3D engine (although,
it later gained the ability to be a 3D modeler, skeletal animation tool, and
a mapper...).

a usable game-like 3D engine can seemingly not manage to ressurect though,
this part seemingly broke away piece by piece over the years...

here are a few shots from around 1 year ago:
http://cr88192.dyndns.org/shots/shots_maps.html

note that, for technical reasons (still lingering bits of Q1-based code,
...), the "main project", is sort of stuck being GPL, but the VM project is
not (does not use any Q1 code), and so I had started on an effort to move
the VM subproject into the public domain (requiring avoidance of using any
GPL parts...).

in 2007 I created a dynamic C compiler (targetting x86 and later x86-64),
which eventually ended up assimilating many other parts of the codebase
(mostly many parts from the original OS project, including the VFS, ...),
and eventually becomming a VM of sorts (although, a VM lacking any sort of
bytecode, so instead it relied mostly on dynamically generating native code
and the use of reflection).

very recently, I ended up writing an x86 interpreter (intended to serve a
role similar to that of a bytecode), this being about the only target I
could support without having to notably alter my existing codebase (likewise
goes for my choice of PE/COFF, ...).

a few parts from other parts of the codebase (primarily the dynamic
assembler and linker) were used in beating together said interpreter.

apparently, all of this is being 'pulled' in a similar direction to the
original OS, but now with the idea that it would all exist within a
userspace app, so a sort of a system within a system occurence...

oddly, another part of my codebase includes a shell which I can probably
partly reuse, ...

but, as far as an overall need or purpose for all this, I really don't
know...

Even in attempting to answer my question about purpose, most of what you
wrote was about random pieces of technology apparently wandering around
in search of a motivation.

It seems possible that the real objective is to play with technology.
There is nothing wrong with that, and it is just as relevant to feature
selection as any other purpose.

If that is the purpose, you need to consider your original questions in
terms of how much fun you would have, and how much you would learn,
implementing different features. Those are questions you will have to
answer for yourself. Newsgroups may be able to help you with how to do
things, and possibly with deciding which things are important given some
external objective, but not with deciding which things you would enjoy
doing.

just me in my own little world I guess, no one really here but myself...

"BGB / cr88192" <cr88...@hotmail.com> wrote in message
news:hc2sr6$6k4$1@news.albasani.net...

this is partly the downside I guess, I do stuff but none of it really seems
to matter or change much of anything...

but, alas, I guess nothing can really be expected to matter unless there is
some reason for it to matter.

I guess the bigger issue is that seemingly there is nothing which can be
done which matters, as what all can be done has already been done by others.

or such...

I suspect it is partly the issue of the practice of using projects to try to
keep depression at bay, as otherwise one is more aware that they are alone
and that there is no one really to talk to...

and, after the many years which have gone by, I am aware that 'project
direction' is not really a strong point. there is a whole lot of "going this
way, changing direction, going that way, ..." and the projects seem to form
in large part out of those pieces which settle out.

almost always, planning is done from the perspective of what I have at the
moment, and what I could do with it, as one feature leads to more features,
...

but, the issue becomes that of 'how is all of this actually useful?...'

no one else really cares or has use for any of this.

in my case, 'useful' is a very open quesion, since I myself have no apparent
usefulness (apparently little more than a waste of time and resources), so
just because I have a use for something does not give it general weight.

it can be inferred that the value of a person is their value to others,
which may manifest in many possible ways, such as monetarily (a person or
their actions can be transformed into financial gain), ability to use them
as a means to an end, ... (for example, the use of the buyer to a seller is
that the buyer will buy a product and make a profit for the seller).

but, what of a person who uses more resources than they produce?... one
could infer that they would be better off not to exist.

...

note here that I am ignoring more metaphysical aspects of value (notions of
'intrinsics', ...). but going into these aspects is where confusion sets in,
so this is more "value which can be understood" and locally assuming the
non-existance of metaphysical or intrinsic properties, ...

but, alas, what 'use' do I have for stuff, as apparently all I really do
with stuff is mess with stuff, nothing more grand or noble, like having a
job or supporting myself, or even something more basic like passing classes,
...

Why not join a really active open-source project that has more change
requests and bug reports than programmers to work on them? Pick up some
bugs that people really care about and fix them. That would get you
working with other people, give you the satisfaction of creating real
value, and let you practice thinking in terms of users and their needs.
Once you have done that, you may see ways in which your own technical
ideas and creativity could be applied to help others.

that is, if I get this far, as usually I end up displeased after a quick
skim of the code, often finding it to be terribly written and a disorganized
mess.

usually I like everything to be partitioned up, with interfaces and
dependencies between subsystems to be defined and enforced (this is actually
one reason why recently I have ended up liking the Windows DLL system as
implemented by MSVC: it indirectly enforces these sorts of practices...).

with DLLs, one has to be mindful of what is imported, what is exported, and
where ones' dependencies are allowed (in contrast to the far more lax
practices implicitly allowed with static linking and with ELF-based shared
objects...).

I like the code to be packaged into "lego-like" blocks that I can put
together as I feel is needed for a given task, which is not generally
possible in many codebases. similarly, it may also allow simply leaving out
parts that would be difficult to build or port, or easily replace parts, ...

so, parts may built, and parts may be torn apart...

hence, I am also big on defining APIs in many cases, where one need not care
how something works internally, so long as it provides a certain API.

again, many opensource projects don't do this, instead preferring to have
one component just muck around with the internals of another component,
which I regard as distasteful...

so, yeah, this is mostly why I tend to dislike many other projects.

(I may make messes sometimes, but usually I at least try to clean them
up...).

(actually, I think this limits my personal life some, as I am similarly
concerned over moral matters, and many people manage to not live up to
baseline requirements...).

actually, generally I guess I use a mix of the bottom-up and top-down
strategies, where the development itself tends to be bottom-up, but I guess
I tend to enforce a modular architecture and design, which is more common in
top-down.

just, I can't do full top-down primarily due to being largely incapable of
keeping an entire project in mind at once, so I guess I tend to mentally
"load" and "unload" components, mostly in terms of their API. (and at times
have noted that I had forgotten how a given component actually worked,
usually when going back and needing to work on it...).

I have ended up on a mildly disfavorable position towards the plain GPL (I
am less resentful of the LGPL though, and had generally been using it,
although it seems many others equate LGPL as essentially the same as the
GPL...).

hence, my recent transition of some parts of my codebase to the public
domain.

or such...

What is it a banker 'produces'?  Certainly the farmer does produce.
Yet the farmer needs the banker for credit to plant next years crop or
maintain the machinery to do it.  So there you have it, a service and
its utility are in the eyes of the participants, value to be
discovered in the market place, on occasion.

But economics has only a few answers.  There are plenty of companies
which take 10 years to turn a profit, but all that time they provide
jobs, develop an industry, provide downstream utility to those who
find some value in their product.

And economics fails when a company shows fat profits by hiding its
waste in drums in the back lot for years until an un-economic disaster
strikes.  What profits us, economics, the dismal science, at that
point?, it has misled us.

-or- -ha-
I hear the U.S. is so short of 'consumers' they'll pay you to be one!

Meanwhile, get back to playing!

Steve

dunno...

yeah...

then again, most of what I have is probably not of much commercial value...

after all, first at least open-source people would have to see value, much
before there would be any real hope of marketability. after all, who would
pay for something that others' wouldn't even want for free?...

people would have value to others, and even though no one has value in their
own right, a sort of value would seem to exist as a sort of emergent network
property or similar...

much like how the economy has worth even though the currency in and of
itself would be valueless...

but, in the global sense, 'value' is not something I have been able to fully
understand, so I take a more local perspective:
'value' is what can be locally observed as valuable;
objects and money have value;
people seem to be valued in their relations to others, in large part, in
terms of objects and money.

(for example, on person caring for another in hope of some form of unspoken
payment...).
payment need not be monetary: procreation, transportation, food, ...

this sort of value could be, in large part, predicted and inferred by the
interactions between people.

or, is there some detail I am missing here?...

admittedly, I am also partially in a depressive phase at the moment as well,
so I don't know...

it is not always clear when ones' thinking is objective, and when it may be
skewed by ones' emotions, so oh well.

granted, me and philosophy are not always on the best of terms...

what is to say that life is much beyond economics?...

just it is the economy of the subtle, of life, of people, and of emotions.
just because one can't really see the transactions as they play out would
not necessarily mean they are not there. so, one person could look for
wealth, and another for happiness, but what is to say that they are all that
different, rather than essentially different forms of essentially the same
things.

so, maybe, one gains wealth at the expense of others, and in a similar way
another happiness at a cost to those around them.

<--
What is it a banker 'produces'?  Certainly the farmer does produce.
Yet the farmer needs the banker for credit to plant next years crop or
maintain the machinery to do it.  So there you have it, a service and
its utility are in the eyes of the participants, value to be
discovered in the market place, on occasion.
-->

yep.

<--
But economics has only a few answers.  There are plenty of companies
which take 10 years to turn a profit, but all that time they provide
jobs, develop an industry, provide downstream utility to those who
find some value in their product.
-->

well, this is a difficult thing to predict.
I guess the issue would be the difficulty of seeing the entire flow of this
'value'.

but, then again, a similar model would seemingly work just as well for
viewing economics, for interpersonal relationships, and for emotions and
ethics. very possibly, all are essentially the same system, working on
similar principles, or maybe even (in a sense) maybe the same algorithms...

but, then again, I have seen also where this path can lead, and there is the
sense that this is not 'right', but what really else is there?... nothing
apparently I can see, nothing I can really seem to understand.

there is 'someone' who I think knows these answers, but they have not been
so inclined to make it so apparent what exact form these answers would take.

allegories which give general ideas (which traditionally have been regarded
as axioms of a sort), but tend not so much to clearly expose the underlying
mechanisms...

<--
And economics fails when a company shows fat profits by hiding its
waste in drums in the back lot for years until an un-economic disaster
strikes.  What profits us, economics, the dismal science, at that
point?, it has misled us.

-or- -ha-
I hear the U.S. is so short of 'consumers' they'll pay you to be one!
-->

well, apparently not according to the local state government, which seems
intent on trying to ever increase taxes...

I am not entirely sure I follow...

Meanwhile, get back to playing!

Steve
-->

maybe...

well, since I have began directly incorporating features such as processes
and threads into the interpreter (this being because the 'kernel' is
essentially the host app, and so OS-level machinery tends to end up in the
interpreter, rather than implemented within the interpreted world...).

I am not currently thinking about implementing all of POSIX, only really
those parts particularly relevant to my uses.

this will mean, for example, interfaces for libdl/pthreads/... but probably
not things like termio, the contents of '/dev', providing lots of shell
commands, ...

many of my 'native' system calls are ending up more looking like they
escaped from the Win32 API though ('NativeCall', which in my case is a
system call of a vaguely similar nature to the .NET 'P/Invoke'
mechanism...).

I am also considering somewhat 'reinterpreting' UID and GID, essentially
making a 'user' a code-level property, rather than corresponding to a
physical user.

this being because, as I see it, the amount of code needing security is
likely much greater than the number of 'users', and personally it seems to
make little sense to me to associate code-level security with the rights of
particular users.

it is like, we need to log in as a non-root user to confine the behavior of
apps?... IMO, this is stupid, and it should be the apps which are confined,
not the user which runs the apps.

granted, logging in as a low-priority user would have a similar effect to
before, but conceptually this would be because the code the user is running
is restricted, not necessarily because the user themselves are restricted.

I am also considering the possibility of applying this to the address space
and ISA as well, in part to work as an "alternative" to the x86 "ring"
model, which does not hold up as well in my architecture (I can't
meaningfully confine the ability of Ring-3 to do system calls, as then no
Ring-3 code can do syscalls, but at the same time, I may want to allow
syscalls from one place but not another, such as only allowing core system
libraries to make system calls, thus forcing non-system libraries to access
the host only via valid library calls...). granted, this much is unorthodox.

it is also partly because the x86 provided methods (call gates, task gates,
and interrupt gates), are not exactly something I even want to touch, and am
maybe better off 'innovating' in this case (and, luckily, this will not
impact any 'valid' code, only that code which attempts to circumvent the
usual mode of operation, and directly try to make use of system calls, ...).

also a few algorithmic changes were made which should significantly speed up
the opcode decoder (likely changing it from absurdly slow, to simply rather
inefficient...).

To "BGB / cr88192",

I always read your posts here and in ALA, even sometimes just diagonally :)

Your ideas remind me of my early attempts to find the one and only solution
for having an OS which supports Linux-, WinDo(w)s-, Mac and my own KESYS
apps.
And finally I ended up with a boot manager and only particular support for
data format conversions.

But 'your way' may be the target anyway ;)

well, I don't really know of an 'ultimate' goal, more just whatever I am
doing at the moment ("the future" is a scary and frustrating place, IMO).

so, for now, I am working on a VM, and have a 3D engine "main project" which
has about fallen on its face (it lacking any particularly meaningful
results...).

it is a pile of stuff, apparently... I wrote 3D modelling tools, but I am
not an artist... how much good does this do me?... (and, most everyone else
is happy with Blender and with the available commercial tools,
apparently...). so, not much use there...

(I use it all, rarely, like when I need to model something...).
(otherwise, it is subject to bit-rot and errosion...).

a VM is at least a little more useful to me personally, but is still of
debatable use in general...

but, the VM project assumes a main project, and it is not nearly as well-off
if my main project collapses (then its main application area has gone away).

yes, ok.

and 'intrinsics' can be more easily determined?...
some people I know argue for 'intrinsic worth', but then claim that there is
no measurable value on this intrinsic worth.

I think it is more like inertia in a closed system:
there are lots of internal interactions and localized non-zero values, even
if possibly the global sum of everything is 0...

to a person, however, the currency itself has a certain value and a buying
power regardless of how one personally regards it, or whether they are
gaining or losing money.

that one has debt does not invert the ability of having money allowing one
to buy things, only that one can't buy since they don't have enough money...

possibly, but in this sense, existence and life itself would also be in the
eye of the beholder...

people can roughly agree if someone or something is alive or dead,
regardless of whether or not 'life' has a place in some ontology.

likely from the POV of most people, it is the objects and money around which
hold value, and other factors are subservient to this.

then again, life and existence likely hold a higher position, since money
and things don't do a whole lot for someone who is dead, and a world full of
things but where everyone is dead would hardly be of much use.

yep, and can be used both to endorse and demean a capitalistic position, yet
oddly one side may be apparently unaware that this mindset can go either way
(to the pursuit of riches and/or industrialization, or to the pursuit of
some socialistic "utopia"...).

possibly, I am a single person who has only seen as much as I have seen...

ok.

it may also be the common mode of operation, where 'win-win' is likely a
minority of cases...

for example, some guy with a well paying job marries:
the female may want his money;
the male may desire to procreate.

in this case, it is win-win, but not all cases are likely as such.

they may attribute it to 'love', but very possibly at a deeper level her
feelings are more based on his money, and his feelings more revolve around
the bedroom, albeit neither may admit this openly (or, possibly, even to
themselves, more sort of like little dark secrets of what they are actually
like, but are not who they want to see themselves as being...).

this much I knew...

but it seemed like there was likely some other intended meaning to this...