Re: [PataPata-discuss] Thinking on PataPata four years later...

[Paul D. F. <pdf...@ku...>]

On 10/6/10 6:32 PM, Paul D. Fernhout wrote:
> Anyway, if PataPata does go forward, I'm thinking it would be in JavaScript
> either on the JVM or even maybe just in a plain web browser (like Lively
> Kernel, but maybe oriented more toward manipulating the HTML DOM).

Coincidental how the advertisement from SourceForge on that email is this:

: Beautiful is writing same markup. Internet Explorer 9 supports
: standards for HTML5, CSS3, SVG 1.1,  ECMAScript5, and DOM L2&  L3.
: Spend less time writing and  rewriting code and more time creating great
: experiences on the web. Be a part of the beta today.

I've been looking into Firebug (which I had seen just before writing that 
note, but had not really understood how much it could do):
   http://getfirebug.com/

I seen now that Firebug is a lot like PataPata (and was releaced a few 
months after the last PataPata version). It's hard to remember what things 
were like four years ago, when it was still iffy how many projects would go 
open source (and what a big thing each opening up was -- like flowers 
opening to the sunshine). Essentially, Firebug includes the PataPata 
inspector. It is not the same, but it is very related, and demonstrates how 
much you can do with a reflective prototype based system. And I'm not saying 
they took any ideas from PataPata, but at the very least, the two probably 
have common roots in Self.

I can see that if I did something with JavaScript, it could make sense to 
integrate code in from Firebug somehow perhaps?

As I continued to look into JavaScript libraries, I came across Sencha Ext 
Designer, which is essentially like PataPata (though with more stuff -- but 
it is not free or embeddable in your application):
   http://www.sencha.com/products/designer/
"Ext Designer is a desktop application that helps you create interfaces 
faster than ever in an easy-to-use, drag-and-drop environment."

So, it looks like essentially people are building businesses around the same 
ideas in PataPata. :-)

But Sencha Ext Designer, for all it looking really amazing, is back to the 
same old paradigm where you need to keep someone who purchases the tool from 
including it in what they release, same as the commercial Smalltalks and 
Lisps would not let you ship the compiler. It is not about making a "live" 
application. Granted, most of the time, that is not what people want, 
especially in the commercial realm.

But, I'm focusing on something different -- how to help people build models 
and discuss them, and that takes being open ended. I'm still trying to do 
this (on a shoestring, and still plugging along on it more than a decade 
later :-):
   "The Garden with Insight garden simulator - Our pre-proposal to the 
National Science Foundation (spring 1997)"
   http://www.gardenwithinsight.com/nsfprop.htm
"We would like to facilitate communication by creating a version 2.0 product 
that includes a model development environment. In version 2.0, users will be 
able to transcend the existing levels of the simulation to make changes to 
the simulation models. Users will change interpreted model source code in an 
environment that incorporates debugging, version control, and flexible data 
storage. Users will be able to collaborate over the internet by exchanging 
source code and data in a self-contained system that requires no external 
tools.
   Here is an example of what we envision for the program. Recently we saw a 
posting on a usenet newsgroup asking if anyone knew of a simulation program 
that modeled seed dispersal. If version 2.0 of Garden with Insight existed 
now, that person could research the scientific literature and add his own 
seed dispersal equations to the existing models. He could add those 
equations to the common bank of source code at the Garden with Insight web 
site, and others could download his code and examine it, review it, and 
incorporate it along with their own modifications. Discussions on seed 
dispersal would include experts in the field and interested non-professionals."

Which links with ideas like:
   http://en.wikipedia.org/wiki/Amateur_professionalism
   http://www.papert.org/articles/HardFun.html
   http://en.wikipedia.org/wiki/Constructivism_%28learning_theory%29

And from:
 
http://seedmagazine.com/content/article/the_essential_parallel_between_science_and_democracy/
"A few months ago, I heard a distinguished biologist declare, holding his 
laptop in his hands, “Without these things, we all die.” A bit of hyperbole 
perhaps, but not so far from the truth."

It's especially true in the sense that we need modern technology to feed 
billions of people now (one of the reason for our garden simulator, to help 
people learn to feed themselves better), and trillions of people in the 
future in self-replicating space habitats that duplicate themselves from 
sunlight and asteroidal ore. I don't agree 100% with everything Julian Simon 
wrote, but he got a lot right about imagination (and related ingenuity, 
effort, learning, etc.) as "the ultimate resource":
   http://www.juliansimon.com/writings/Ultimate_Resource/

So, as people said about Squeak, PataPata wants to help people image, learn, 
play, create, and share (to borrow a bit of phrasing at the end from Little 
Big Planet that also shares aspirations of PataPata):
   http://en.wikipedia.org/wiki/LittleBigPlanet

So, what I see is that the PataPata vision is winning (even if maybe 
PataPata itself, so far, is losing. :-)

But, as thankful as I am for the success of the vision, it is still sad to 
have been just at the edges of that (even if the edge is the "forefront". 
:-) And, of course, there were many people before me -- Seymour Papert, Alan 
Kay, Dan Ingalls, Adele Goldberg, Ted Kaehler, Scott Wallace, etc..
   "The Early History of Smalltalk"
   http://gagne.homedns.org/~tgagne/contrib/EarlyHistoryST.html
   http://en.wikipedia.org/wiki/Smalltalk
   http://www.viewpointsresearch.org/

So, I'm just swimming with the same sorts of whales they have long swum 
with, although maybe in a different place. :-)

Anyway, so, a big choice is whether to move PataPata forward on something 
like using JavaScript/Rhino on the JVM and Swing, or whether to move it 
forward in the web browser (improving on Firebug), or whether to do 
something different (or just code Twirlip etc. in Java without a dynamic 
infrastructure to avoid getting bogged down in making tools instead of 
apps). Still, I tend to like to make tools more than apps. :-)

It's sad Squeak was not this thing. I can regret not helping more. Now I see 
that best thing to do might have been to fork it right away (before the 
Disney move) and stabilize it (merging in any useful Squeak core team 
contributions) and hope for a later license revision from Apple:
   http://groups.google.com/group/comp.lang.smalltalk/msg/f2eb9258f08b9764?hl=en
"Squeak does have other limitations besides speed. It has some minor
bugs, lacks dynamic linking to C (except on the Acorn), lacks support
for OLE, lacks some convenience accessors, lacks built in exception
handling (though this is in the works and you can already file in
something to give a basic facility), lacks ENVY support (although you
can easily get versions of previous methods in your change log), and so
on."

But, 20/20 hindsight is pretty easy. :-)

So, what is easy now is to build on JavaScript, the JVM, and the web 
browser. It's too bad though that JavaScript does not have a message passing 
model at the core (with "does not understand"), even if you can maybe add it 
or even use some variant of JavaScript that adds it somehow and compiles to 
pure JavaScript as a VM:
   http://return42.blogspot.com/2009/07/smalltalk-like-message-passing-in.html

But even adding message passing to JavaScript still leaves a confusion 
between when to call functions and when to change properties (I like 
Smalltalk's only having methods that are accessible outside the class, not 
the instance variables). There is never any confusion in Smalltalk for a 
caller about when you might want to access an instance variable for, say, 
length, because you can't. :-)

Anyway, Alan Kay joked that my PataPata critique was a real tribute to Dan 
Ingalls' design, and I have to agree. :-) And I can see that a big value of 
message passing is it scales in a way that is problematical for functional 
and imperative systems.

And Dan Ingalls has again led the way with a choice of JavaScript (although, 
once again, it's not a microscope/telescope hybrid so much as a 
everything-is-in-one-world thing). So, a niche for PataPata in JavaScript 
would be trying to be the microscope/telescope that like Firebug looks at 
its own code and other code, using whatever tools and abstractions are 
available to do that.
   "[Edu-sig] Comments on Kay's Reinvention of Programming proposal (was Re: 
More Pipeline News)"
   http://mail.python.org/pipermail/edu-sig/2007-March/007822.html
   http://forum.world.st/Traits-or-not-Traits-that-is-the-question-td71548.html

It's taken a while for me to see this, but, with JavaScript, essentially 
each web page can be seen like a Smalltalk ObjectMemory (or text-based image 
like PataPata writes out). While I work towards using the Pointrel System to 
add triples in a declarative way, in practice, the web of calling cgi 
scripts at URLs is a lot like message passing (just more like the earlier 
Smalltalk-72 way without well-defined syntax). So, essentially, a web of 
HTML pages with JavaScript and CGI on servers is like the Smalltalk system 
written large. :-) Just in a very ad hoc and inelegant way. :-)

--Paul Fernhout
http://www.pdfernhout.net/
====
The biggest challenge of the 21st century is the irony of technologies of 
abundance in the hands of those thinking in terms of scarcity.