[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: Logo

On Sat, 14 Aug 1999, Ian Bicking wrote:

> Scott Raney <raney@metacard.com> wrote:
> > > Is there anyplace where I can read a more technical/formal 
> > > description of one of the *Talk languages?  I've never used them, 
> > > and the recent experience with MetaTalk has only left me a bit 
> > > mystified.  In mimicking English it seems to leave out some 
> > > regularity -- but maybe I just haven't seen what the underlying rules 
> > > are.
> > 
> > It's very English-like, but this serves primarily as a mnemonic device
> > (it makes remembering the names of the commands and the order of
> > parameters easier, for example).  It also often helps with syntax, but
> > this is certainly a double-edged sword because it doesn't understand
> > most English sentences as people sometimes expect it to ;-)
> I'm wondering about things like datatypes -- things in quotes seem 
> to be everything from message-sends to strings to lists.  All the 
> syntactic sugar -- "to" and "in" and such -- is there a pattern to 
> that, or does it just mimic English?

The use of prepositions and articles is just like English, and much of
it is optional.  But even the most hard-core developers use the
abbreviated terms and 1 character variable names rather than cut
corners here because it's hard to read the scripts if you do.

>  Is there a good definition for 
> what "this" and "the" mean?  The reference manual has mostly 
> examples, which would be enough in a more regular language but 
> leaves me a bit confused.  It's just curiosity, really, but it would be 
> the easiest way for me to learn the language.

There's more context in the xTalk language than most others I think.
You frequently using things like "this card" or "this stack" or "the
target" (the object that got a message") or "me" (the object whose
script is executing).  This greatly simplifies development and
maintainability and aids readability because you don't have to carry
around global variables to hold handles to the various objects like
you do in most other languages.

> > > But I think we're talking about two things here (though in the same 
> > > thread).  There's the authoring system, but there is also a 
> > > programming environment.  To the degree MetaCard or even 
> > > HyperStudio is a programming environment, it is *much* different 
> > > from Logo.
> > 
> > This is certainly true, but mostly because Logo environments are so
> > abstracted from the look and behavior of common applications.  I'm of
> > the opinion that programming is programming, and that all that really
> > matters is getting the concepts down so that you can have fun with it.
> > On the other hand, that doesn't mean I'd go so far as to recommend a
> > language with goto in it as a first language ;-)
> The first steps into programming don't have to take the form of a 
> program.  Typically a student will play around with individual 
> commands, FD 100, RT 90, that sort of thing.  It's nothing like a 
> program, but it is a simple place to begin.  Then you place a 
> sequence of actions in a row, give them a name, and you have your 
> first procedure.
> Something like MetaCard seems to come at it from the opposite 
> direction.  Instead of working with simple primitives and putting 
> them together into something bigger, you start out with the whole 
> thing (a stack) and fill in the details.  It's a much different 
> experience.

Not really.  Most people learn scripting by starting small and even
most large-scale projects start out with simple prototypes similar to
what you've described.  You should note that "hello world" is 0 lines
of code in MetaTalk, because all this type of information is stored in
the stack database (i.e., you create a button and name it "hello
world" and this is saved as a binary resource, when the stack opens,
this is displayed).  There isn't a lot of stuff you have to write
before you start doing the real work as you'd see in C or even in Tcl
or Perl.  And MetaTalk programs usually start out by programming
interactions, just like in your Logo example.  The difference is
instead of moving a turtle, the interactions are typically to put some
text into a text field, or open a dialog and ask the user to type some
text.  These are things that kids can relate to a lot more easily than
turtle graphics if they've had any application experience at all,
because they've seen it done so many times in those applications.

> > > I think Logo is much more appropriate for teaching programming 
> > > from a mathematic/algorithmic perspective.  It is quite formal and 
> > > minimalistic with few special forms, lends itself to a substitution 
> > > model fairly easily, is based on procedures instead of messages... 
> > > it's a lot like math.
> > 
> > Agreed.  And while I agree that this may be a viable alternative
> > approach, I worry a lot about transfer (Logo is not very much like C
> > or Visual Basic or Java, which are all much more similar to xTalk),
> > and also in having frustration set in before any real progress can be
> > made.  There's no getting around the fact that learning programming is
> > hard.  But making it as easy as possible will allow the greatest
> > number of students to benefit from acquiring this skill.
> I don't think xTalk looks any more similar to the Algol-ish 
> languages than Logo.  But I don't think it really matters.

It probably doesn't, until you try to create a useful program with it.
The similarity I was refering too isn't about the language themselves,
but how they interact with graphical elements like buttons and fields.
Logo doesn't have these.  xTalk (like VB and and Java and C as it is
used today) has this stuff built in.

> Logo isn't for votech.  Nobody is going to get a programming job 
> after learning Logo.  And at the levels where Logo is taught, they 
> typically won't be able to get a job programming regardless of what 
> language they are taught.
> The idea with Logo is to teach programming not as a skill but as a 
> pedagogical tool.  Some kids may never program again, but 
> hopefully they will have learned something anyway -- not just about 
> computers, but about the more general concepts as well: variables, 
> functions, explicit algorithms, geometry...

And a worthwhile goal it is.  But my argument is just that as long as
there's no difference in learnability or the concepts learned in the
languages, why not teach one that *can* be used by both 4th graders
and professionals?  Some of the best-known members of the MetaCard
community are in high-school or recently out of it, something also
common to the HyperCard and SuperCard communities.  Many of these kids
start working on commercial contracts before they graduate from
high-school (a situation fraught with it's own little problems, but
that's mostly a worry for the people that hire them without asking
them enough about how many other projects they've brought in on time,
estimating being something that it's hard to teach ;-)

> > >  Logo was designed very 
> > > much for pedagogy, but the *Talk languages seem more about 
> > > functionality and ease of learning.  Those are different ideals. 
> > > Logo  has lots of abreviations because little kids type very very
> > > slowly... is MetaTalk sensitive to those sorts of problems?  It
> > > seems like it's intended for more literate audiences than Logo.
> > 
> > I guess it depends on what you're doing with it.  If teaching turtle
> > graphics to 3rd graders, you're probably right.  But the cryptic
> > command names and syntax make it much harder for middle schoolers to
> > develop more sophisticated applications with Logo.
> The syntax is highly regular -- more so than most languages.  I 
> think this is positive for working up from simple commands to 
> complex statements.  You can predict how things will work when 
> you put them together.  Like you said, in xTalk it looks like 
> English, but if you try to write an English statement it probably 
> won't work.  It's nice to read, but not as easy to write.  Logo isn't 
> terribly great for reading (better than C, though), but it's good for 
> writing.  Having both easy reading and easy writing would be nice -- 
> I think Smalltalk kind of manages this -- but neither xTalk or Logo 
> achieves this.

Again, I was refering more to what you have to do to program
interactivity than just in building larger procedures (which is not
much different in any language as far as I know).  This is one of the
most important things that kids should learn how to do, and one of the
less standardized aspects of Logo (HyperLogo in HyperStudio in
particular makes a real hash of accessing the objects from the Logo
language).  I saw a couple of posts about adding this kind of thing to
Logo on this list just today, so obviously it's an issue.  But
grafting something like this onto Logo would be vastly more difficult
(and probably much uglier) than adding something like turtle graphics
to xTalk (if that's what turns you on.  Myself, I consider the xTalk
statements "move button 1 from 10,10 to 100,100" or "move image 1
relative -10,-40" a more than adequate way to teach kids about moving
things around on a coordinate plane).

> --
> Ian Bicking <bickiia@earlham.edu>

Scott Raney  raney@metacard.com  http://www.metacard.com
MetaCard: You know, there's an easier way to do that...