On 5/27/2011 4:29 PM, Jecel Assumpcao Jr. wrote:
snip...
coming out of lurk mode for the moment (well, also no-one has really
been talking to me recently either...)
["Wireworld Computer"]
It is very cute. The circuit style of the Wireworld might actually be
the way of the future if quantum dots catch on.
http://en.wikipedia.org/wiki/Quantum_dot_cellular_automaton
http://nd.edu/~qcahome/
interesting... actually, the above also sort of vaguely reminds me of
the "redstone" system in Minecraft (where one is basically putting one
of several types of "voxels" in various configurations in order to
create logic gates and similar). however, yes, there are differences...
I was also recently thinking about, if one had a sufficiently powerful
computer (say, distant-future technology), if it would be possible to
approximately emulate workable physics with the computer using less
physical space, energy, time, ... than is present within the simulated
environment (say, a computer that fits in a single building and
simulates a town or city, say down to the level of atomic and chemical
interactions...).
in a brute-force sense, the answer would probably be "no", but a
computer-based simulation may be able to make enough "simplifying
assumptions" in order to be able to run a larger environment than
itself. although, I suspect a concept similar to the Shannon Limit would
likely still apply, and hence the simulation could not likely be
implemented recursively (a computer simulating 4 of itself, each in turn
simulating 4 more, ...).
but, what could be possible would be, say, recognizing common classes of
molecules, and then probably using pre-programed logic, rather than
simulating atomic interactions, or detecting and simulating general
material properties (using FEM/...) rather than directly simulating the
individual molecules (such that it doesn't waste all its time with
things like simulating the movement of all of the H2O molecules in a
glass of water, or simulating the individual electrons flowing along in
a piece of wire, ...).
(never-mind me possibly hijacking the thread with the below...)
I also thought the video earlier (in the other conversation) about
Erlang was interesting.
granted, although probably no one cares, for a custom scripting language
of mine (which uses a syntax which is currently a mix of ActionScript
and Java style syntax), for which I am using a slightly unusual object
system and scoping model:
well, the present form of the object system combines a Class/Instance
system with a Prototype system, where basically instances can be cloned,
and classes with a "dynamic" modifier can have fields added (ok,
ActionScript also does similar).
however, variables can also be marked as "delegate" which basically
allows variable/method accesses to transparently go through the variable
(IIRC, the original idea came from Self, but there is always of a chance
that my memory has degraded some...). likewise, delegation chains may be
cyclic.
note that, unlike in some languages, one is not (entirely) confined to
using statically visible declarations (although the VM may optimize for
many cases where it can statically determine visibility, as well as the
whole "big hash table of fields and methods" trick).
similarly, the type-system mixes static and dynamic types, so which is
used and when is mostly a matter of personal preference (a present
standing goal though is to make it more type-safe though...)
in the past, some ideas from Erlang had also been interesting (mostly
async message passing and "processes"), although I have not done nearly
as much with these ideas as I would have liked (sadly, some of the more
interesting ideas around are difficult to mesh cleanly with a world
largely implemented in C...).
I do make some use of message-passing based on the usage of queues of
S-Expressions (Lisp-style Lists). message-queues / "mailboxes" are
sort-of good enough. this concept could be easily enough extended over a
network by passing the lists over a socket (maybe in a binary serialized
format). most of my current usage is within a single process though (I
don't presently do much involving networks).
in the past, I also had asynchronous methods, which generally used
lightweight threading to implement the method calls, but these are not
presently available.
well, and other random features my stuff once had, but later fell into
oblivion:
a largely network-transparent memory model (based on handles and copying);
ability to push live threads over a socket (any code/objects/... being
pulled over piecewise);
...
but, sadly, the ability to implement a feature does not carry with it
having much personal use for it (and the whole problem of complex
features being prone to quickly bit-rot away...).
yes, all sort of boring and pointless, I know...
I guess the video did mention something I found fairly notable
(something I have held for a long time):
often, implementing a language or VM itself is not really the main problem;
rather, it is all of the stuff "around" the language...
a "perfect" language really wouldn't buy much if it can't really
interface with or do much of anything... most of us probably don't
really have the time or resources to rebuild the world in ones' own
image, or at least, this is my outlook.
I much more often try to leverage things where possible, but still end
up getting in fights with people over what things I have and have not
reused (for example, me choosing to implement my own native VM, rather
than building on LLVM / JVM / .NET / ... but to me, these do seem a bit
much like bringing in a 10kLB gorilla for doing what is, effectively,
high-level scripting for a C-based app, regardless of the not exactly
small number of kLOC in my VM project, which to be fair, about 80% of
this is more various support machinery than is the VM itself...).
nor is it probably that huge of an issue exactly how long it takes to
evaluate "fib(35)" or "fib(40)" with the usual recursive Fibonacci
function, provided it is "fast enough" for what it needs to do.
but, it is also like me standing for my right to implement much of my
stuff in C, rather than buying into doing everything "the C++ way"... I
really don't get it sometimes...
or such...
_______________________________________________
fonc mailing list
[email protected]
http://vpri.org/mailman/listinfo/fonc
