By your leave, I have a few basic questions I'd like to ask:
1. I downloaded a package called lively-fx.12.02.08 from your downloads
page. I don't understand anything about how subversion works, so maybe I did
something wrong. As far as I can understand this is a webpage. I should be
able to drag index.xhtml to a browser icon from the folder on the desktop
and get the same result as the Start The Very Latest Version link on the
homepage. Or I could double click index.html, click "here" and see the gui.
Am I confused about that? You'd deploy this in the server the same way as
any index.html file. You'd just ensure all the <def></def> files in the
<svg></svg> were immediately available. No?
2. What are these ".jar" files for? Those are Java binaries, I'm guessing,
3. You used classical inheritance with subclass() and extend() to implement
Morphic, right? That means you're bringing Morphic to SVG is from Squeak and
not from Self. Is that correct? For some reason I thought I'd see the true
way to use prototypical inheritance in Lively Kernel, as I had it in my mind
The Google Talks video was very useful.
Learning about Self I see that the versatility of that language comes@a
price. It's simple code. And I like the wholeness of it enough to explore it
further, but it seems to use a smaller unit of composition than the class.
The slot is a sort of mobile method, it seems to me. My point is that I
think people find this language a bit confusing, Self and JS both, because
the unit of construction, the granularity of the language, is much smaller
than people are used to. They implement classical inheritance everywhere to
use a larger unit of construction, I think. What have you taken from Mr.
5. How did you develop this? I mean, I'd like to have some Self or Squeak
have a browser window to see a chain from top to bottom. Did you use such a
tool? I can't see writing Core.js, which prints out to 124- pages, as one
file you worked on in vi or BBEdit. You must have had some kind of IDE.
Firebug is great, but it couldn't be so useful. .. could it?
I'd like to say now that there are probably several material
misunderstandings in the questions I've asked, and I apologize for mistaking
things that are perhaps obvious to some. But as I said to Elliot Miranda on
his blog: "Well, if you're here..."
-------------- next part --------------
An HTML attachment was scrubbed...
I can't answer the Lively-Kernel-specific questions, but I've got a
couple of thoughts about the more general prototype-based-system ones.
(We could take this discussion over to
http://groups.yahoo.com/group/self-interest/ if it's not appropriate
> 3. You used classical inheritance with subclass() and extend() to implement
> Morphic, right? That means you're bringing Morphic to SVG is from Squeak and
> not from Self. Is that correct? For some reason I thought I'd see the true
> way to use prototypical inheritance in Lively Kernel, as I had it in my mind
Even in Self, we use a class-like pattern a lot of the time (see
I'm not very familiar with the Lively Kernel code base, but it doesn't
surprise me that it uses a lot of classes. And if I glance through LK,
it looks to me like there are a few objects that aren't class
instances, which is about what I'd expect.
The way I usually think about it, classes are a fine idea; it's just
the idea that "every object is an instance of a class" that causes
trouble. The value of prototypes isn't that you suddenly organize your
entire code base in this whole new completely-different way; it's that
the core of the system becomes simpler and more flexible and easier to
learn. That flexibility lets you use some fun new organizational
patterns, but the good old "class" pattern is still an important one.
> Learning about Self I see that the versatility of that language comes@a
> price. It's simple code. And I like the wholeness of it enough to explore it
> further, but it seems to use a smaller unit of composition than the class.
> The slot is a sort of mobile method, it seems to me. My point is that I
> think people find this language a bit confusing, Self and JS both,
> because the unit of construction, the granularity of the language, is
> much smaller than people are used to.
I'm not quite sure what you mean. Self's module system uses slot-level
granularity because when you're loading a module into the image it's
useful to be able to add stuff to existing objects. That's certainly
not unique to prototype-based systems - for example, open up a Squeak
image and look for method categories with an asterisk in front of
their names. (That's the mechanism that Squeak uses to indicate that
the methods in that category should belong to a different module than
the one the class belongs to.) Lively Kernel seems to be doing
something similar - occasionally using Object.extend to add slots to
|Free forum by Nabble
|Edit this page