On 2/26/2012 11:43 PM, Julian Leviston wrote:
Hi,
Comments line...
On 27/02/2012, at 5:33 PM, BGB wrote:
I don't think it was a prank. It's not really hidden at all. If you
pay attention, all the components of Frank are there... like I said.
It's obviously missing certain things like Nothing, and other
optimisations, but for the most part, all the tech is present.
sorry for asking, but is their any sort of "dense people friendly"
version, like maybe a description on the Wiki or something?...
like, so people can get a better idea of "what things are about and
how they all work and fit together"?... (like, in the top-down
description kind of way?).
I don't think this is for people who aren't prepared to roll up their
sleeves and try things out. For a start, learn SmallTalk. It's not
hard. Go check out squeak. There are lots of resources to learn SmallTalk.
could be.
I messed with Squeak some before, but at the time got
confused/discouraged and gave up after a little while.
My major stumbling block at the moment is understanding OMeta fully.
This is possibly the most amazing piece of work I've seen in a long,
long time, and there's no easy explanation of it, and no really
simple explanation of the syntax, either. There are the papers, and
source code and the sandboxes, but I'm still trying to understand
how to use it. It's kind of huge. I think perhaps I need to get a
grounding in PEGs before I start on OMeta because there seems to be
a lot of assumed knowledge there. Mostly I'm having trouble with the
absolute, complete basics.
Anyway I digress... have you had a look at this file?:
http://piumarta.com/software/maru/maru-2.1/test-pepsi.l
Just read the whole thing - I found it fairly interesting :) He's
build pepsi on maru there... that's pretty fascinating, right? Built
a micro smalltalk on top of the S-expression language... and then
does a Fast Fourier Transform test using it...
my case: looked some, but not entirely sure how it works though.
You could do what I've done, and read the papers and then re-read them
and re-read them and re-read them... and research all references you
find (the whole site is totally full of references to the entire of
programming history). I personally think knowing LISP and SmallTalk,
some assembler, C, Self, Javascript and other things is going to be
incredibly helpful. Also, math is the most helpful! :)
ASM and C are fairly well known to me (I currently have a little over 1
Mloc of C code to my name, so I can probably fairly safely say "I know
C"...).
I used Scheme before, but eventually gave up on it, mostly due to:
problems with the Scheme community (seemed to be very fragmented and
filled with elitism);
I generally never really could "get over" the look of S-Expression
syntax (and also the issue that no one was happy unless the code had
Emacs formatting, but I could never really get over Emacs either);
I much preferred C style control flow (which makes arbitrary
continues/breaks easier), whereas changing flow through a loop in Scheme
often meant seriously reorganizing it;
...
Scheme remains as a notable technical influence though (and exposure to
Scheme probably had a fairly notable impact on much of my subsequent
coding practices).
JavaScript I know acceptably, given my own scripting language is partly
based on it.
however, I have fairly little experience using it in its original
context: for fiddling around with web-page layouts (and never really got
into the whole "AJAX" thing).
I messed around with Self once before, but couldn't get much
"interesting" from it, but I found the language spec and some papers on
the VM fairly interesting, so I scavenged a bunch of ideas from there.
the main things I remember:
graph of objects, each object being a "bag of slots", with the ability
to delegate to any number of other objects, and the ability to handle
cyclic delegation loops;
using a big hash-table for lookups and similar;
...
many of those ideas were incorporated into my own language/VM (with
tweaks and extensions: such as my VM has lexical scoping, and I later
added delegation support to the lexical environment as well, ...). (I
chose free-form / arbitrary delegation rather than the single-delegation
of JavaScript, due to personally finding it more useful and interesting).
I had noted, however, that my model differs in a few significant ways
from the description of Lieberman Prototypes on the site (my "clone"
operation directly copies objects, rather than creating a new empty
object with copy-on-write style semantics).
the current beast looks like a mix of like a C/JS/AS mix on the surface,
but internally may have a bit more in common than Scheme and Self than
it does with other C-like languages (much past the syntax, and
similarities start to fall away).
but, yet, I can't really understand SmallTalk code...
granted, math is a big weak area of mine:
apparently, my effective upper limit seems to be roughly at the level of
linear algebra and similar;
however, beyond the trivial cases, I am I suspect unable to understand
things like "set theory" and similar, and my thinking generally falls
apart when dealing with things like integrals.
I can understand both boolean logic and aggregates, but then there is
set theory, which starts having aspects of both and everything falls
apart at this point.
however, apparently set-theory is the basis for SQL, and I can
understand SQL well enough, so I don't know (to me though, SQL looks
like applying boolean operations to members of an table though, so is
easy enough to imagine if one just imagines that the query is a
collection of several nested loops...). (although some elements of SQL's
syntax design are confusing, the syntax seems partly built on magic...).
I can also sort of deal with visualizing 4D spaces, but have a harder
time, and have ran into problems due to my mental projections having a
hard time visualizing 4D spaces without introducing distortion. at one
point, I ended up embarrassing myself by thinking a plane in a 4D space
was curved, because my imagination had projected it with an obvious
curve, and was then emberrassed by someone pointing out a little detail:
there were no exponents anywhere, so the plane could not be curved...
(but, responding "but it looked curved in my head" is a fairly weak
response...).
but, I personally suspect that math is evil in some ways, as it is
difficult to deal with it without running into stupid errors and making
a fool of oneself...
ironically, I can fairly easily understand RPN but not really SSA, and
can understand Recursive Descent easily enough, but have a harder time
LALR and similar (and personally have often just assumed use RD for
pretty much everything...).
typically, in these cases, one option seems fairly simple/obvious (such
as RPN or Recursive Descent), whereas the other seems bewildering (such
as SSA or LALR).
or such...
_______________________________________________
fonc mailing list
fonc@vpri.org
http://vpri.org/mailman/listinfo/fonc
