Re: Control? Object?

[Richmond]

On 20.06.2016 19:58, Mark Waddingham wrote:

On 2016-06-20 16:38, Richmond wrote:

Thank you very much indeed for the comprehensive reply.

I shall deal with the children's confusion by using neither 'object'
or 'control' and
just refer to buttons, fields and so on.

I know this is dodging the issue; but I can see no other way round it
at the moment.


That seems entirely reasonable!

At the end of the day it is no different from the techniques I've 
observed myself being used used to teach many other 
what-you-might-call 'technical' disciplines


In Mathematics, we are taught 'Calculus' as almost a purely symbolic 
mechanism 


At Durham, the head of Philosophy in 1984 (Dr P.J.Fitzpatrick) a 
brilliant, mad and lovely man, lined
up a series of wine glasses filled to various depths with wine, and 
started tapping tunes out on them,
and if I understand anything about Calculus and Curves, it is down to 
his explanation, which
contextualised it in a way quite unlike our poor benighted Maths teacher 
at school who could
neither control teenage boys nor explain Calculus in any sort of way 
that made sense.


And, certainly, with the 8-14 year old crowd, 'symbolic', 'theoretical' 
and 'metaphorical' are

very dirty words indeed.

first (usually at age 17-18 in the UK) which comes with a whole load 
of 'edge cases' you just have to accept and then only in later years 
is it 're-explained' based on the epsilon-delta arguments of 
'Analysis' (usually at first year degree level). (Amusingly I remember 
having real trouble getting my head around the idea of epsilon-delta 
arguments - my head had been so entrenched in the computably finite 
world of computing at that point that 'tending to a limit' seemed a 
somewhat impossible notion).


I still haven't got my head round basic Calculus: and, oddly enough, 
have managed to make my way

in the world without having managed it.

One thing I have never quite understood is why it seems to be assumed 
that to program computers
(or, perhaps, we should say "programme computers" to keep Jerry Jensen's 
teeth grinding) one has to
have a fairly advanced knowledge of Maths, when all that seems to be 
necessary is a spot of basic

BODMAS (Brackets, Of, Divide, Multiply, Add, Subtract) and elementary LOGIC.



Similarly, I remember my first A-level Chemistry class (age 17) where 
we were told - "all you have been told up until now has been 'lies'" 
in particular with relation to the structure of the atom and bonding.


Indeed: I remember our Chemistry teacher telling us to forget 
"valencies" and start
learning about "oxidation states". In fact I remember getting sent out 
of the room because I,
inevitably, asked the obvious question: "If all you've taught us before 
is lies, why should we not assume

that what you are about to teach us is not another load of the same?"

Poor old Dr Lewis . . . while he had a doctorate from Sheffield in 
Non-Ferrous Metallic

something-or-others, he kept getting all those organic synthesis cycles
badly wrong, and he was totally useless when it came to working with 
adolescent boys.


As my father said: "Anyone with a doctorate in Chemistry who ends up 
teaching in a

secondary school . . ."

Well; I don't have a doctorate, and have no great academic pretensions; 
but what I do know
is that explaining things that computer programming involves to the 
middle-school crowd is

not particularly easy.

Probably the fancy academic qualifications are less important than an 
ability to enthuse young people

and communicate sufficient concepts to get them going.

As to "edge cases" . . . Ha, Ha, Ha; I could make a fairly offensive 
remark here; but won't, as,

necessarily, I'd have to include myself in that category :-)

Thanks, as always, for your support and your well thought-out replies.

Best, Richmond.




Warmest Regards,

Mark.




___
use-livecode mailing list
use-livecode@lists.runrev.com
Please visit this url to subscribe, unsubscribe and manage your subscription 
preferences:
http://lists.runrev.com/mailman/listinfo/use-livecode

Re: Control? Object?

[Mark Waddingham]

On 2016-06-20 14:48, David Bovill wrote:

Great post Mark. I'm going to keep that for my notes!

I've too tangentially related questions - mainly with regard to what it 
is
better to do with widgets and with script. You say "the ability to be 
able
to package up a group of controls as a black-box just like a widget 
would
be entirely consistent and self-similar with the existing environment." 
I'd

like to know what you are thinking :)

My question are:

  1) Does the ability / robustness of using compound widgets - vs doing 
the

same with groups make it a here and now option to do compound layouts
within widgets only? How does this relate to your "black box" comment
above. I ask because I do a lot of compound nested groups with 
behaviours,

and I am wandering what bits to shift o widget only.


Well, rewriting existing code probably should only be done *if there are 
tangible advantages to doing so*.


At present you cannot 'wrap up' existing LiveCode Script objects as a 
widget with an 'inner script' (which would be akin to the code you write 
for a widget right now). It is, however, something which would fit with 
the current model of LiveCode Script very well - when we can figure out 
how to do it.


Widgets are completely encapsulated (compared to Script groups with 
behaviors) which has numerous advantages for all kinds of 'leaf' 
controls (things which have no real substructure and are 'just' a 
rendering of data in some fashion). This is mainly because rendering is 
done 'on demand' so your widget can have as many graphical elements as 
you like, without the (sometimes significant!) overhead of many many 
controls you would need in LiveCode Script. (The advantages are not only 
down to lower overhead, but also editing in the IDE and grokking by 
Script - even though you can 'hide' substructure of LiveCode groups in 
the Project Browser, that are still part of the object tree from 
Script's point of view which means you do, at the very least, have to 
make sure you name things appropriately lest scripts accidentally manage 
to resolve a reference to one of the objects in one of your control's 
groups rather than one they meant to).


Basically, if you have group-based controls which are essentially just 
collections of graphics and areas to interact with the mouse and touch 
and don't require other script controls within them to be manipulated 
from outside the control then they would likely make good candidates for 
widgetization. In Script, you don't need to tweak properties of numerous 
objects whenever the data changes - you just issue a 'redraw all' inside 
the widget and the OnPaint handler causes the display to be updated.


For example, the Clock widget would consist of 16 internal controls if 
it were a LiveCode group-based control - and on each resize you'd have 
to work out all the scaling and positioning and set all the properties 
of each of those objects. As a widget, however, you set up the transform 
appropriately in OnPaint then just render to a unit-square based on the 
time which is currently set as a property. When the time changes, you 
just 'redraw all' and OnPaint triggers to update the display.



  2) Which animation and paint routines are significantly better with
Builder so that making a widget is preferable to doing the same with 
groups
and script. In particular how about rostering images, of doing 
animations?


As Builder uses the same image caching mechanism as Script, there isn't 
probably much performance difference between changing the id of an image 
to do animation compared to doing the same within a widget.


However, in Builder you have access to a full 2d Canvas API - including 
full affine transformations so you can do more in a widget with 
graphics, more easily. Also, the widget canvas you render to is 
completely sub-pixel based meaning you get a higher fidelity of display 
then you would get using graphics (as they currently are).


In terms of animation, one advantage of widgets is that the 'Timer' 
mechanism they currently have is entirely internal to the widget - you 
don't see any messages in the pending messages, and suspend and resume 
is automatically handled between Edit and Browse mode. This simplifies 
coding to a good degree as well as minimising any interaction with other 
scripts running and the internal operation of your widget (control).


So, if you have custom controls currently which are visualizations of 
some data, and don't require any user input beyond mouse interaction (or 
any at all) then they probably are really good candidates for turning 
into widgets.


I know Trevor has had great success in improving the UIs in his 
applications by using widgets as they allow him to much more easily 
create easy to use controls which render precisely how you need - what 
might require 3 or 4 graphics and a couple of fields before now, can be 
done with a single control. The latter simplifies the script view of the 
object tree, as well as 

Re: Control? Object?

[Mark Waddingham]

On 2016-06-20 16:38, Richmond wrote:

Thank you very much indeed for the comprehensive reply.

I shall deal with the children's confusion by using neither 'object'
or 'control' and
just refer to buttons, fields and so on.

I know this is dodging the issue; but I can see no other way round it
at the moment.


That seems entirely reasonable!

At the end of the day it is no different from the techniques I've 
observed myself being used used to teach many other what-you-might-call 
'technical' disciplines


In Mathematics, we are taught 'Calculus' as almost a purely symbolic 
mechanism first (usually at age 17-18 in the UK) which comes with a 
whole load of 'edge cases' you just have to accept and then only in 
later years is it 're-explained' based on the epsilon-delta arguments of 
'Analysis' (usually at first year degree level). (Amusingly I remember 
having real trouble getting my head around the idea of epsilon-delta 
arguments - my head had been so entrenched in the computably finite 
world of computing at that point that 'tending to a limit' seemed a 
somewhat impossible notion).


Similarly, I remember my first A-level Chemistry class (age 17) where we 
were told - "all you have been told up until now has been 'lies'" in 
particular with relation to the structure of the atom and bonding.


Warmest Regards,

Mark.

--
Mark Waddingham ~ m...@livecode.com ~ http://www.livecode.com/
LiveCode: Everyone can create apps

___
use-livecode mailing list
use-livecode@lists.runrev.com
Please visit this url to subscribe, unsubscribe and manage your subscription 
preferences:
http://lists.runrev.com/mailman/listinfo/use-livecode

Re: Control? Object?

[Devin Asay]

Mark,

Thanks for this fantastic explanation of controls and objects and lots more. 
I’m happy to learn that what I’ve always thought I understood is not far off 
from reality. :) The definig of audioclips and videoclips as objects, not 
controls, within the stack tree, cleared up one point of confusion for me. I 
had always explained *clips to students as “objects that have no visual 
component.”

Now as regards any fixes and changes to terminology in the docs (Guides or 
dictionary API), I would be happy to help anyone who sees a confusing passage 
and who would like to fix it. I have recently been doing a fair amount of work 
as time permits to make improvements to the dictionary and user guides. If you 
see a problem in the docs and don’t have the time to grok the Github system, 
drop me a note and I’d be happy to help out.

Regards,

Devin


> On Jun 20, 2016, at 3:28 AM, Mark Waddingham  wrote:
> 
> On 2016-06-19 09:19, Richmond wrote:
>> I am currently teaching some children Livecode programming and ran
>> into some difficulty
>> on Friday when a child asked me why the menus were full of the word "Control"
>> when I had been talking about "Objects".
>> Well?
>> How about changing every use of the word "Control" to "Object"?
> 
> Replying to the original post, as a lot was mentioned in this thread (it 
> tries to cover most of what came up in the thread, not just this particular 
> question).
> 
> An object (regardless of what language it is rendered in, or with whatever 
> specific kind of 'oop' methodology you care to subscribe to) is simply some 
> state (i.e. variables which are distinct for each instance of the object) 
> with an associated list of handlers/methods/functions which act on that 
> state. (Indeed, really I think one should require that the state is entirely 
> hidden and encapsulated within the object and not visible from the outside 
> world - although most OOP languages do this very very poorly).
> 
> In LiveCode, this is perhaps slightly hidden behind the English-like 
> syntactic sugar. For example, one can imagine that:
> 
>   get the fooBar of myObject
> 
> Is the same as (in a non English-like language):
> 
>   it := myObject.GetFooBar()
> 
> Or something like:
> 
>   copy myObject
> 
> Is the same as (again, in a non English-like language):
> 
>   myObject.Copy()
> 
> Therefore, I have absolutely no hesitation in saying that LiveCode is 
> object-oriented (for some definition of object-oriented). Indeed, it always 
> has been - everyone who has ever programming in an xTalk had been doing 
> object-oriented programming since it started to become 'popular' (HyperCard 
> appeared in 1987, Cfront - the original C++ - appeared in 1985 - although the 
> first 'object oriented' languages such as Simula appeared perhaps a decade 
> before).
> 
> The reason why I tend to hesitate saying LiveCode is object-oriented 
> explicitly (well, up until 8, at least) is that the kind of way you do 
> programming in LiveCode is perhaps not quite the same as what people expect 
> when they hear that 'a language is object oriented'. The LiveCode model is 
> essentially that of aggregation and adaptation, rather than inheritance 
> (people tend to be highly aware of the later, but not aware of the former 
> even though they will be implicitly doing it day-in-day-out in any 
> programming language they are a practitioner of).
> 
> In LiveCode, you build applications by using the building-blocks you drag 
> from the control palette to build more complicated things (aggregation), and 
> then you apply scripts to each object to change the behavior of the 
> building-blocks appropriate to your app (adaptation).
> 
> Now, inheritance is orthogonal to the idea of aggregation and adaptation - 
> and it should be noted that most 'traditional' OOP languages allow you to do 
> inheritance, but you have to build the framework to do aggregation and 
> adaptation yourself (hence why Java, Obj-C, C++ etc. all have a large variety 
> of 'frameworks' you can leverage to actually build apps - if you tried to do 
> so with the 'raw' language, you'll find yourself just reinventing some sort 
> of structure which is probably not too dissimilar to LiveCode's).
> 
> When we added 'behaviors' you could argue that 'inheritance' did actually 
> start to creep in - behaviors allow you to factor out the code which you use 
> to adapt the building blocks (i.e. your scripts) into an informal hierarchy. 
> (Informal here refers to the fact you don't need to make type definitions - 
> which is entirely appropriate to LiveCode which tends not to force that kind 
> of thing on you anywhere - except in Builder, and only then if you really 
> want to).
> 
> With 8, however, you can start to see the 'class inheritance' ability being 
> added to LiveCode - that is what widgets are. i.e. You can write your own 
> building blocks (in LiveCode Builder). (For those of you who have looked at 
> Builder, then although it 

Re: Control? Object?

[Richmond]

Your students might be "the opposite of tech-savvy", but they are 
neither in the 8-14 age range, nor
native Bulgarian speakers (unless there is something you're not telling 
us about Utah).


R.

On 20.06.2016 18:33, Devin Asay wrote:

Yes, that’s true no doubt. But I think part of the reason it hasn’t been a 
confusion is because I start out by defining what an “object” is (it could just 
as well be a doohickey), then asserting that control doohickies are a subset of 
all doohickies, and then sticking with the same terminology throughout the 
course. Then when they encounter the term doohickey or control in the 
documentation they read past it because we’ve already defined the term. My 
students are the opposite of tech-savvy and couldn’t care less if LC is a 
“true” doohickey-oriented language. :D

Cheers,

Devin



On Jun 20, 2016, at 8:21 AM, Richmond  wrote:

I would like to think that there is a significant difference, Devin, between 
your University
students and my small children.

The children I teach actually believe that 'objects' are things that exist 
inside a computer,
rather than metaphorical abstractions drawn on a screen because we cannot cope 
with
endless lines of zeroes and ones.

Richmond.

On 20.06.2016 03:05, Devin Asay wrote:

This is an interesting discussion, but I’ll admit it has never been a source of 
confusion for me or my students. I announce on day 1: “Everything in LiveCode 
is an object.” And then: “Controls are objects that can be placed on cards to 
create a user interface.” Going forward I usually refer to objects you can 
place on cards as “control objects”. Then we move on, and I don’t ever remember 
having someone be confused about that point. Another way to think about it is 
that all of the thingies on the tools palette are control objects.

My .02.

Devin



On Jun 19, 2016, at 12:16 PM, Richmond  wrote:

On 19.06.2016 19:56, FlexibleLearning.com wrote:

To me the terms "control" and "object" are synonymous.



They may be synonymous to you; but all they do is cause confusion in the
"tiny minds" of 9 - 14 year old children who haven't heard about Piaget's
Formal Operational Stage, nor reached it.

You are, after all, an extremely experienced programmer who, probably, doesn't 
even murmur
'object' or 'control' under one's breath while choosing a button any more (if 
you ever did), as you have
internalised all that to such an extent that those terms are neither here nor 
there. I know
that I have.

The other problem has nothing, as such, to do with naming conventions decided
by Livecode developers or other computer people, but to do with people's
perceptions of what they see on their WIMP GUI on a computer VDU.

A quick, impromptu survey involving 3 children (9 - 11 years old, my father
(83 years old) and myself [don't quote this one in your next academic paper]
tells me that folk will see a difference between 2 classes of 'things':

1. Stacks & Cards (I mean, let's face facts, stacks are essentially invisible 
(or, maybe, as files
in one's directory) and only visualised through their cards).

2. Things that sit on cards (buttons, images, fields, et al).

AND, to that 'stack of cards' metaphor. How many teachers are bothering to pull 
out
a pack of playing cards to illustrate this to kids who are in the Concrete 
Operational Stage
and can't 'see' a Livecode as a pile of cards to save their lives?

A child, on Friday, said this, when I made him a second card: "Oh, a second 
page."

The 'stack of cards' metaphor has become so entrenched in our brains after 
years of bashing away at
Hypercard, SERF, HyperNext, HyperStudio (ooh, look [ 
http://www.mackiev.com/hyperstudio/select.html ] they have just released the 
ability to export to HTML5), Supercard, Metacard,
Runtime Revolution - Livecode, blah,  blah, that we assume it is automatic in 
new users, when, in fact,
it may not necessarily be useful or relevant anymore. Especially, if, unlike 
people like Bill Atkinson,
we don't come from a culture where we stack our pancakes up into one big pile and 
"stuff our mushes", nor play cards on a regular basis.

My Granny, from Carnoustie via Dundee, used to impose a horribly boring card 
game on my sister
and I every time she came to visit, called "Sevens", and whenever she was in 
danger of losing
announce, "Ach, I've got a hand like a sweaty foot." Which put me off cards 
almost completely.

Now; it does seem sensible to call things that sit on cards (buttons, images, 
fields, et al) 'objects',
because, frankly, not all of them CONTROL things: surely, only things that 
contain scripts CONTROL things?

To illustrate how daft calling things on cards 'controls' is, imagine calling 
the black (or white) blotches
on a Frisian cow "organs", when they are so obviously different from things 
such as mouths, eyes, ears
and udders.

Now, undoubtedly, SOME objects may become controls (by being gifted scripts), 
but that's 

Re: Control? Object?

[Devin Asay]

Yes, that’s true no doubt. But I think part of the reason it hasn’t been a 
confusion is because I start out by defining what an “object” is (it could just 
as well be a doohickey), then asserting that control doohickies are a subset of 
all doohickies, and then sticking with the same terminology throughout the 
course. Then when they encounter the term doohickey or control in the 
documentation they read past it because we’ve already defined the term. My 
students are the opposite of tech-savvy and couldn’t care less if LC is a 
“true” doohickey-oriented language. :D

Cheers,

Devin


> On Jun 20, 2016, at 8:21 AM, Richmond  wrote:
> 
> I would like to think that there is a significant difference, Devin, between 
> your University
> students and my small children.
> 
> The children I teach actually believe that 'objects' are things that exist 
> inside a computer,
> rather than metaphorical abstractions drawn on a screen because we cannot 
> cope with
> endless lines of zeroes and ones.
> 
> Richmond.
> 
> On 20.06.2016 03:05, Devin Asay wrote:
>> This is an interesting discussion, but I’ll admit it has never been a source 
>> of confusion for me or my students. I announce on day 1: “Everything in 
>> LiveCode is an object.” And then: “Controls are objects that can be placed 
>> on cards to create a user interface.” Going forward I usually refer to 
>> objects you can place on cards as “control objects”. Then we move on, and I 
>> don’t ever remember having someone be confused about that point. Another way 
>> to think about it is that all of the thingies on the tools palette are 
>> control objects.
>> 
>> My .02.
>> 
>> Devin
>> 
>> 
>>> On Jun 19, 2016, at 12:16 PM, Richmond  wrote:
>>> 
>>> On 19.06.2016 19:56, FlexibleLearning.com wrote:
 To me the terms "control" and "object" are synonymous.
>>> 
>>> 
>>> They may be synonymous to you; but all they do is cause confusion in the
>>> "tiny minds" of 9 - 14 year old children who haven't heard about Piaget's
>>> Formal Operational Stage, nor reached it.
>>> 
>>> You are, after all, an extremely experienced programmer who, probably, 
>>> doesn't even murmur
>>> 'object' or 'control' under one's breath while choosing a button any more 
>>> (if you ever did), as you have
>>> internalised all that to such an extent that those terms are neither here 
>>> nor there. I know
>>> that I have.
>>> 
>>> The other problem has nothing, as such, to do with naming conventions 
>>> decided
>>> by Livecode developers or other computer people, but to do with people's
>>> perceptions of what they see on their WIMP GUI on a computer VDU.
>>> 
>>> A quick, impromptu survey involving 3 children (9 - 11 years old, my father
>>> (83 years old) and myself [don't quote this one in your next academic paper]
>>> tells me that folk will see a difference between 2 classes of 'things':
>>> 
>>> 1. Stacks & Cards (I mean, let's face facts, stacks are essentially 
>>> invisible (or, maybe, as files
>>> in one's directory) and only visualised through their cards).
>>> 
>>> 2. Things that sit on cards (buttons, images, fields, et al).
>>> 
>>> AND, to that 'stack of cards' metaphor. How many teachers are bothering to 
>>> pull out
>>> a pack of playing cards to illustrate this to kids who are in the Concrete 
>>> Operational Stage
>>> and can't 'see' a Livecode as a pile of cards to save their lives?
>>> 
>>> A child, on Friday, said this, when I made him a second card: "Oh, a second 
>>> page."
>>> 
>>> The 'stack of cards' metaphor has become so entrenched in our brains after 
>>> years of bashing away at
>>> Hypercard, SERF, HyperNext, HyperStudio (ooh, look [ 
>>> http://www.mackiev.com/hyperstudio/select.html ] they have just released 
>>> the ability to export to HTML5), Supercard, Metacard,
>>> Runtime Revolution - Livecode, blah,  blah, that we assume it is automatic 
>>> in new users, when, in fact,
>>> it may not necessarily be useful or relevant anymore. Especially, if, 
>>> unlike people like Bill Atkinson,
>>> we don't come from a culture where we stack our pancakes up into one big 
>>> pile and "stuff our mushes", nor play cards on a regular basis.
>>> 
>>> My Granny, from Carnoustie via Dundee, used to impose a horribly boring 
>>> card game on my sister
>>> and I every time she came to visit, called "Sevens", and whenever she was 
>>> in danger of losing
>>> announce, "Ach, I've got a hand like a sweaty foot." Which put me off cards 
>>> almost completely.
>>> 
>>> Now; it does seem sensible to call things that sit on cards (buttons, 
>>> images, fields, et al) 'objects',
>>> because, frankly, not all of them CONTROL things: surely, only things that 
>>> contain scripts CONTROL things?
>>> 
>>> To illustrate how daft calling things on cards 'controls' is, imagine 
>>> calling the black (or white) blotches
>>> on a Frisian cow "organs", when they are so obviously different from things 
>>> such as mouths, eyes, 

Re: Control? Object?

[Richmond]

Thank you very much indeed for the comprehensive reply.

I shall deal with the children's confusion by using neither 'object' or 
'control' and

just refer to buttons, fields and so on.

I know this is dodging the issue; but I can see no other way round it at 
the moment.


Richmond.

On 20.06.2016 12:28, Mark Waddingham wrote:

On 2016-06-19 09:19, Richmond wrote:

I am currently teaching some children Livecode programming and ran
into some difficulty
on Friday when a child asked me why the menus were full of the word 
"Control"

when I had been talking about "Objects".

Well?

How about changing every use of the word "Control" to "Object"?


Replying to the original post, as a lot was mentioned in this thread 
(it tries to cover most of what came up in the thread, not just this 
particular question).


An object (regardless of what language it is rendered in, or with 
whatever specific kind of 'oop' methodology you care to subscribe to) 
is simply some state (i.e. variables which are distinct for each 
instance of the object) with an associated list of 
handlers/methods/functions which act on that state. (Indeed, really I 
think one should require that the state is entirely hidden and 
encapsulated within the object and not visible from the outside world 
- although most OOP languages do this very very poorly).


In LiveCode, this is perhaps slightly hidden behind the English-like 
syntactic sugar. For example, one can imagine that:


   get the fooBar of myObject

Is the same as (in a non English-like language):

   it := myObject.GetFooBar()

Or something like:

   copy myObject

Is the same as (again, in a non English-like language):

   myObject.Copy()

Therefore, I have absolutely no hesitation in saying that LiveCode is 
object-oriented (for some definition of object-oriented). Indeed, it 
always has been - everyone who has ever programming in an xTalk had 
been doing object-oriented programming since it started to become 
'popular' (HyperCard appeared in 1987, Cfront - the original C++ - 
appeared in 1985 - although the first 'object oriented' languages such 
as Simula appeared perhaps a decade before).


The reason why I tend to hesitate saying LiveCode is object-oriented 
explicitly (well, up until 8, at least) is that the kind of way you do 
programming in LiveCode is perhaps not quite the same as what people 
expect when they hear that 'a language is object oriented'. The 
LiveCode model is essentially that of aggregation and adaptation, 
rather than inheritance (people tend to be highly aware of the later, 
but not aware of the former even though they will be implicitly doing 
it day-in-day-out in any programming language they are a practitioner 
of).


In LiveCode, you build applications by using the building-blocks you 
drag from the control palette to build more complicated things 
(aggregation), and then you apply scripts to each object to change the 
behavior of the building-blocks appropriate to your app (adaptation).


Now, inheritance is orthogonal to the idea of aggregation and 
adaptation - and it should be noted that most 'traditional' OOP 
languages allow you to do inheritance, but you have to build the 
framework to do aggregation and adaptation yourself (hence why Java, 
Obj-C, C++ etc. all have a large variety of 'frameworks' you can 
leverage to actually build apps - if you tried to do so with the 'raw' 
language, you'll find yourself just reinventing some sort of structure 
which is probably not too dissimilar to LiveCode's).


When we added 'behaviors' you could argue that 'inheritance' did 
actually start to creep in - behaviors allow you to factor out the 
code which you use to adapt the building blocks (i.e. your scripts) 
into an informal hierarchy. (Informal here refers to the fact you 
don't need to make type definitions - which is entirely appropriate to 
LiveCode which tends not to force that kind of thing on you anywhere - 
except in Builder, and only then if you really want to).


With 8, however, you can start to see the 'class inheritance' ability 
being added to LiveCode - that is what widgets are. i.e. You can write 
your own building blocks (in LiveCode Builder). (For those of you who 
have looked at Builder, then although it is not yet explicit - a 
module is essentially a class - a widget is a module which can have 
multiple instances and a library is a module which only ever has a 
single instance).


So, right now in LiveCode, the objects you have to play with are 
stacks, cards, audioclips, videoclips, fields, buttons, scrollbars, 
players, images, buttons, groups, graphics and widgets. However, 
remember that 'widgets' are a completely extensible set of things, so 
this list is no longer fixed as it was before.


To go back to the original point about controls vs objects then this 
is actually very well defined (indeed, it is embodied in the source of 
the engine - i.e. how LiveCode is actually implemented). A control is 
an object which sits on a card 

Re: Control? Object?

[Richmond]

I would like to think that there is a significant difference, Devin, 
between your University

students and my small children.

The children I teach actually believe that 'objects' are things that 
exist inside a computer,
rather than metaphorical abstractions drawn on a screen because we 
cannot cope with

endless lines of zeroes and ones.

Richmond.

On 20.06.2016 03:05, Devin Asay wrote:

This is an interesting discussion, but I’ll admit it has never been a source of 
confusion for me or my students. I announce on day 1: “Everything in LiveCode 
is an object.” And then: “Controls are objects that can be placed on cards to 
create a user interface.” Going forward I usually refer to objects you can 
place on cards as “control objects”. Then we move on, and I don’t ever remember 
having someone be confused about that point. Another way to think about it is 
that all of the thingies on the tools palette are control objects.

My .02.

Devin



On Jun 19, 2016, at 12:16 PM, Richmond  wrote:

On 19.06.2016 19:56, FlexibleLearning.com wrote:

To me the terms "control" and "object" are synonymous.



They may be synonymous to you; but all they do is cause confusion in the
"tiny minds" of 9 - 14 year old children who haven't heard about Piaget's
Formal Operational Stage, nor reached it.

You are, after all, an extremely experienced programmer who, probably, doesn't 
even murmur
'object' or 'control' under one's breath while choosing a button any more (if 
you ever did), as you have
internalised all that to such an extent that those terms are neither here nor 
there. I know
that I have.

The other problem has nothing, as such, to do with naming conventions decided
by Livecode developers or other computer people, but to do with people's
perceptions of what they see on their WIMP GUI on a computer VDU.

A quick, impromptu survey involving 3 children (9 - 11 years old, my father
(83 years old) and myself [don't quote this one in your next academic paper]
tells me that folk will see a difference between 2 classes of 'things':

1. Stacks & Cards (I mean, let's face facts, stacks are essentially invisible 
(or, maybe, as files
in one's directory) and only visualised through their cards).

2. Things that sit on cards (buttons, images, fields, et al).

AND, to that 'stack of cards' metaphor. How many teachers are bothering to pull 
out
a pack of playing cards to illustrate this to kids who are in the Concrete 
Operational Stage
and can't 'see' a Livecode as a pile of cards to save their lives?

A child, on Friday, said this, when I made him a second card: "Oh, a second 
page."

The 'stack of cards' metaphor has become so entrenched in our brains after 
years of bashing away at
Hypercard, SERF, HyperNext, HyperStudio (ooh, look [ 
http://www.mackiev.com/hyperstudio/select.html ] they have just released the 
ability to export to HTML5), Supercard, Metacard,
Runtime Revolution - Livecode, blah,  blah, that we assume it is automatic in 
new users, when, in fact,
it may not necessarily be useful or relevant anymore. Especially, if, unlike 
people like Bill Atkinson,
we don't come from a culture where we stack our pancakes up into one big pile and 
"stuff our mushes", nor play cards on a regular basis.

My Granny, from Carnoustie via Dundee, used to impose a horribly boring card 
game on my sister
and I every time she came to visit, called "Sevens", and whenever she was in 
danger of losing
announce, "Ach, I've got a hand like a sweaty foot." Which put me off cards 
almost completely.

Now; it does seem sensible to call things that sit on cards (buttons, images, 
fields, et al) 'objects',
because, frankly, not all of them CONTROL things: surely, only things that 
contain scripts CONTROL things?

To illustrate how daft calling things on cards 'controls' is, imagine calling 
the black (or white) blotches
on a Frisian cow "organs", when they are so obviously different from things 
such as mouths, eyes, ears
and udders.

Now, undoubtedly, SOME objects may become controls (by being gifted scripts), 
but that's beside
the point when one shows a bunch of learners (whether they are either 9 or 83 
years old,
or anywhere in between) a collections of things (buttons, images, fields, et 
al) on a card, as they have
not yet become controls as they have not had scripts written into their 
scriptEditor windows.

I wonder if it might not be a good idea to get a load of 9 year old native 
speakers to sit down in front
of a VDU displaying a Livecode 'page' containing a load of 'objects' and ask 
those children what they
would call them as a group of things.

Certainly, what ever "those things" are called, the apparent conflict in the Dictionary 
between the "Obj"
words and the "Controls" mentioned in the Menus does cause confusion in young 
minds (and it may in
others for all I know).

So, for learning purposes at least, I would say "B*gger the official terms", 
what is needed is a coherent
set of terms for 

Re: Control? Object?

[David Bovill]

Great post Mark. I'm going to keep that for my notes!

I've too tangentially related questions - mainly with regard to what it is
better to do with widgets and with script. You say "the ability to be able
to package up a group of controls as a black-box just like a widget would
be entirely consistent and self-similar with the existing environment." I'd
like to know what you are thinking :)

My question are:

  1) Does the ability / robustness of using compound widgets - vs doing the
same with groups make it a here and now option to do compound layouts
within widgets only? How does this relate to your "black box" comment
above. I ask because I do a lot of compound nested groups with behaviours,
and I am wandering what bits to shift o widget only.

  2) Which animation and paint routines are significantly better with
Builder so that making a widget is preferable to doing the same with groups
and script. In particular how about rostering images, of doing animations?

On Monday, 20 June 2016, Mark Waddingham  wrote:

> On 2016-06-19 09:19, Richmond wrote:
>
>> I am currently teaching some children Livecode programming and ran
>> into some difficulty
>> on Friday when a child asked me why the menus were full of the word
>> "Control"
>> when I had been talking about "Objects".
>>
>> Well?
>>
>> How about changing every use of the word "Control" to "Object"?
>>
>
> Replying to the original post, as a lot was mentioned in this thread (it
> tries to cover most of what came up in the thread, not just this particular
> question).
>
> An object (regardless of what language it is rendered in, or with whatever
> specific kind of 'oop' methodology you care to subscribe to) is simply some
> state (i.e. variables which are distinct for each instance of the object)
> with an associated list of handlers/methods/functions which act on that
> state. (Indeed, really I think one should require that the state is
> entirely hidden and encapsulated within the object and not visible from the
> outside world - although most OOP languages do this very very poorly).
>
> In LiveCode, this is perhaps slightly hidden behind the English-like
> syntactic sugar. For example, one can imagine that:
>
>get the fooBar of myObject
>
> Is the same as (in a non English-like language):
>
>it := myObject.GetFooBar()
>
> Or something like:
>
>copy myObject
>
> Is the same as (again, in a non English-like language):
>
>myObject.Copy()
>
> Therefore, I have absolutely no hesitation in saying that LiveCode is
> object-oriented (for some definition of object-oriented). Indeed, it always
> has been - everyone who has ever programming in an xTalk had been doing
> object-oriented programming since it started to become 'popular' (HyperCard
> appeared in 1987, Cfront - the original C++ - appeared in 1985 - although
> the first 'object oriented' languages such as Simula appeared perhaps a
> decade before).
>
> The reason why I tend to hesitate saying LiveCode is object-oriented
> explicitly (well, up until 8, at least) is that the kind of way you do
> programming in LiveCode is perhaps not quite the same as what people expect
> when they hear that 'a language is object oriented'. The LiveCode model is
> essentially that of aggregation and adaptation, rather than inheritance
> (people tend to be highly aware of the later, but not aware of the former
> even though they will be implicitly doing it day-in-day-out in any
> programming language they are a practitioner of).
>
> In LiveCode, you build applications by using the building-blocks you drag
> from the control palette to build more complicated things (aggregation),
> and then you apply scripts to each object to change the behavior of the
> building-blocks appropriate to your app (adaptation).
>
> Now, inheritance is orthogonal to the idea of aggregation and adaptation -
> and it should be noted that most 'traditional' OOP languages allow you to
> do inheritance, but you have to build the framework to do aggregation and
> adaptation yourself (hence why Java, Obj-C, C++ etc. all have a large
> variety of 'frameworks' you can leverage to actually build apps - if you
> tried to do so with the 'raw' language, you'll find yourself just
> reinventing some sort of structure which is probably not too dissimilar to
> LiveCode's).
>
> When we added 'behaviors' you could argue that 'inheritance' did actually
> start to creep in - behaviors allow you to factor out the code which you
> use to adapt the building blocks (i.e. your scripts) into an informal
> hierarchy. (Informal here refers to the fact you don't need to make type
> definitions - which is entirely appropriate to LiveCode which tends not to
> force that kind of thing on you anywhere - except in Builder, and only then
> if you really want to).
>
> With 8, however, you can start to see the 'class inheritance' ability
> being added to LiveCode - that is what widgets are. i.e. You can write your
> own building blocks (in 

Re: Control? Object?

[Mark Waddingham]

On 2016-06-19 09:19, Richmond wrote:

I am currently teaching some children Livecode programming and ran
into some difficulty
on Friday when a child asked me why the menus were full of the word 
"Control"

when I had been talking about "Objects".

Well?

How about changing every use of the word "Control" to "Object"?


Replying to the original post, as a lot was mentioned in this thread (it 
tries to cover most of what came up in the thread, not just this 
particular question).


An object (regardless of what language it is rendered in, or with 
whatever specific kind of 'oop' methodology you care to subscribe to) is 
simply some state (i.e. variables which are distinct for each instance 
of the object) with an associated list of handlers/methods/functions 
which act on that state. (Indeed, really I think one should require that 
the state is entirely hidden and encapsulated within the object and not 
visible from the outside world - although most OOP languages do this 
very very poorly).


In LiveCode, this is perhaps slightly hidden behind the English-like 
syntactic sugar. For example, one can imagine that:


   get the fooBar of myObject

Is the same as (in a non English-like language):

   it := myObject.GetFooBar()

Or something like:

   copy myObject

Is the same as (again, in a non English-like language):

   myObject.Copy()

Therefore, I have absolutely no hesitation in saying that LiveCode is 
object-oriented (for some definition of object-oriented). Indeed, it 
always has been - everyone who has ever programming in an xTalk had been 
doing object-oriented programming since it started to become 'popular' 
(HyperCard appeared in 1987, Cfront - the original C++ - appeared in 
1985 - although the first 'object oriented' languages such as Simula 
appeared perhaps a decade before).


The reason why I tend to hesitate saying LiveCode is object-oriented 
explicitly (well, up until 8, at least) is that the kind of way you do 
programming in LiveCode is perhaps not quite the same as what people 
expect when they hear that 'a language is object oriented'. The LiveCode 
model is essentially that of aggregation and adaptation, rather than 
inheritance (people tend to be highly aware of the later, but not aware 
of the former even though they will be implicitly doing it 
day-in-day-out in any programming language they are a practitioner of).


In LiveCode, you build applications by using the building-blocks you 
drag from the control palette to build more complicated things 
(aggregation), and then you apply scripts to each object to change the 
behavior of the building-blocks appropriate to your app (adaptation).


Now, inheritance is orthogonal to the idea of aggregation and adaptation 
- and it should be noted that most 'traditional' OOP languages allow you 
to do inheritance, but you have to build the framework to do aggregation 
and adaptation yourself (hence why Java, Obj-C, C++ etc. all have a 
large variety of 'frameworks' you can leverage to actually build apps - 
if you tried to do so with the 'raw' language, you'll find yourself just 
reinventing some sort of structure which is probably not too dissimilar 
to LiveCode's).


When we added 'behaviors' you could argue that 'inheritance' did 
actually start to creep in - behaviors allow you to factor out the code 
which you use to adapt the building blocks (i.e. your scripts) into an 
informal hierarchy. (Informal here refers to the fact you don't need to 
make type definitions - which is entirely appropriate to LiveCode which 
tends not to force that kind of thing on you anywhere - except in 
Builder, and only then if you really want to).


With 8, however, you can start to see the 'class inheritance' ability 
being added to LiveCode - that is what widgets are. i.e. You can write 
your own building blocks (in LiveCode Builder). (For those of you who 
have looked at Builder, then although it is not yet explicit - a module 
is essentially a class - a widget is a module which can have multiple 
instances and a library is a module which only ever has a single 
instance).


So, right now in LiveCode, the objects you have to play with are stacks, 
cards, audioclips, videoclips, fields, buttons, scrollbars, players, 
images, buttons, groups, graphics and widgets. However, remember that 
'widgets' are a completely extensible set of things, so this list is no 
longer fixed as it was before.


To go back to the original point about controls vs objects then this is 
actually very well defined (indeed, it is embodied in the source of the 
engine - i.e. how LiveCode is actually implemented). A control is an 
object which sits on a card or in a group.


Indeed, you have the following 'inheritance' hierarchy:

Object
   Stack
   Card
   AudioClip
   VideoClip
   Control
 Group
 Field
 Button
 Scrollbar
 Player
 Image
 Button
 Graphic
 Widget
   

This means 

Re: Control? Object?

[Peter TB Brett]

On 19/06/2016 15:28, Richmond wrote:

So:

Should I stop using the word 'Object' for Buttons, Fields and so on while
teaching children, and make sure I refer to all of those things as
'Controls'; even if only
for the simple reason that the menus keep referring to 'Controls'?


All controls are objects.

Not all objects are controls.

Stacks and cards are excellent examples of objects that are not controls.

"object" and "control" are NOT synonymous.  If you find a place in the 
documentation where the words are used inappropriately, it would be 
great to get it fixed.  However, search-and-replacing "control" to 
"object" would not be useful, accurate, sensible, or acceptable.


   Peter

--
Dr Peter Brett 
LiveCode Technical Project Manager

LiveCode 2016 Conference: https://livecode.com/edinburgh-2016/

___
use-livecode mailing list
use-livecode@lists.runrev.com
Please visit this url to subscribe, unsubscribe and manage your subscription 
preferences:
http://lists.runrev.com/mailman/listinfo/use-livecode

Re: Control? Object?

[Devin Asay]

This is an interesting discussion, but I’ll admit it has never been a source of 
confusion for me or my students. I announce on day 1: “Everything in LiveCode 
is an object.” And then: “Controls are objects that can be placed on cards to 
create a user interface.” Going forward I usually refer to objects you can 
place on cards as “control objects”. Then we move on, and I don’t ever remember 
having someone be confused about that point. Another way to think about it is 
that all of the thingies on the tools palette are control objects. 

My .02.

Devin


> On Jun 19, 2016, at 12:16 PM, Richmond  wrote:
> 
> On 19.06.2016 19:56, FlexibleLearning.com wrote:
>> To me the terms "control" and "object" are synonymous.
> 
> 
> 
> They may be synonymous to you; but all they do is cause confusion in the
> "tiny minds" of 9 - 14 year old children who haven't heard about Piaget's
> Formal Operational Stage, nor reached it.
> 
> You are, after all, an extremely experienced programmer who, probably, 
> doesn't even murmur
> 'object' or 'control' under one's breath while choosing a button any more (if 
> you ever did), as you have
> internalised all that to such an extent that those terms are neither here nor 
> there. I know
> that I have.
> 
> The other problem has nothing, as such, to do with naming conventions decided
> by Livecode developers or other computer people, but to do with people's
> perceptions of what they see on their WIMP GUI on a computer VDU.
> 
> A quick, impromptu survey involving 3 children (9 - 11 years old, my father
> (83 years old) and myself [don't quote this one in your next academic paper]
> tells me that folk will see a difference between 2 classes of 'things':
> 
> 1. Stacks & Cards (I mean, let's face facts, stacks are essentially invisible 
> (or, maybe, as files
> in one's directory) and only visualised through their cards).
> 
> 2. Things that sit on cards (buttons, images, fields, et al).
> 
> AND, to that 'stack of cards' metaphor. How many teachers are bothering to 
> pull out
> a pack of playing cards to illustrate this to kids who are in the Concrete 
> Operational Stage
> and can't 'see' a Livecode as a pile of cards to save their lives?
> 
> A child, on Friday, said this, when I made him a second card: "Oh, a second 
> page."
> 
> The 'stack of cards' metaphor has become so entrenched in our brains after 
> years of bashing away at
> Hypercard, SERF, HyperNext, HyperStudio (ooh, look [ 
> http://www.mackiev.com/hyperstudio/select.html ] they have just released the 
> ability to export to HTML5), Supercard, Metacard,
> Runtime Revolution - Livecode, blah,  blah, that we assume it is automatic in 
> new users, when, in fact,
> it may not necessarily be useful or relevant anymore. Especially, if, unlike 
> people like Bill Atkinson,
> we don't come from a culture where we stack our pancakes up into one big pile 
> and "stuff our mushes", nor play cards on a regular basis.
> 
> My Granny, from Carnoustie via Dundee, used to impose a horribly boring card 
> game on my sister
> and I every time she came to visit, called "Sevens", and whenever she was in 
> danger of losing
> announce, "Ach, I've got a hand like a sweaty foot." Which put me off cards 
> almost completely.
> 
> Now; it does seem sensible to call things that sit on cards (buttons, images, 
> fields, et al) 'objects',
> because, frankly, not all of them CONTROL things: surely, only things that 
> contain scripts CONTROL things?
> 
> To illustrate how daft calling things on cards 'controls' is, imagine calling 
> the black (or white) blotches
> on a Frisian cow "organs", when they are so obviously different from things 
> such as mouths, eyes, ears
> and udders.
> 
> Now, undoubtedly, SOME objects may become controls (by being gifted scripts), 
> but that's beside
> the point when one shows a bunch of learners (whether they are either 9 or 83 
> years old,
> or anywhere in between) a collections of things (buttons, images, fields, et 
> al) on a card, as they have
> not yet become controls as they have not had scripts written into their 
> scriptEditor windows.
> 
> I wonder if it might not be a good idea to get a load of 9 year old native 
> speakers to sit down in front
> of a VDU displaying a Livecode 'page' containing a load of 'objects' and ask 
> those children what they
> would call them as a group of things.
> 
> Certainly, what ever "those things" are called, the apparent conflict in the 
> Dictionary between the "Obj"
> words and the "Controls" mentioned in the Menus does cause confusion in young 
> minds (and it may in
> others for all I know).
> 
> So, for learning purposes at least, I would say "B*gger the official terms", 
> what is needed is a coherent
> set of terms for end-users.
> 
> Richmond.
> 
> 
> ___
> use-livecode mailing list
> use-livecode@lists.runrev.com
> Please visit this url to subscribe, unsubscribe and manage your 

Re: Control? Object?

[Jim Lambert]

“I object!”, he protested.
“Control yourself!”, she replied.
Later they agreed, “It was just one of those things.”

Jim Lambert
___
use-livecode mailing list
use-livecode@lists.runrev.com
Please visit this url to subscribe, unsubscribe and manage your subscription 
preferences:
http://lists.runrev.com/mailman/listinfo/use-livecode

Re: Control? Object?

[Richmond]

On 19.06.2016 19:56, FlexibleLearning.com wrote:

To me the terms "control" and "object" are synonymous.




They may be synonymous to you; but all they do is cause confusion in the
"tiny minds" of 9 - 14 year old children who haven't heard about Piaget's
Formal Operational Stage, nor reached it.

You are, after all, an extremely experienced programmer who, probably, 
doesn't even murmur
'object' or 'control' under one's breath while choosing a button any 
more (if you ever did), as you have
internalised all that to such an extent that those terms are neither 
here nor there. I know

that I have.

The other problem has nothing, as such, to do with naming conventions 
decided

by Livecode developers or other computer people, but to do with people's
perceptions of what they see on their WIMP GUI on a computer VDU.

A quick, impromptu survey involving 3 children (9 - 11 years old, my father
(83 years old) and myself [don't quote this one in your next academic paper]
tells me that folk will see a difference between 2 classes of 'things':

1. Stacks & Cards (I mean, let's face facts, stacks are essentially 
invisible (or, maybe, as files

in one's directory) and only visualised through their cards).

2. Things that sit on cards (buttons, images, fields, et al).

AND, to that 'stack of cards' metaphor. How many teachers are bothering 
to pull out
a pack of playing cards to illustrate this to kids who are in the 
Concrete Operational Stage

and can't 'see' a Livecode as a pile of cards to save their lives?

A child, on Friday, said this, when I made him a second card: "Oh, a 
second page."


The 'stack of cards' metaphor has become so entrenched in our brains 
after years of bashing away at
Hypercard, SERF, HyperNext, HyperStudio (ooh, look [ 
http://www.mackiev.com/hyperstudio/select.html ] they have just released 
the ability to export to HTML5), Supercard, Metacard,
Runtime Revolution - Livecode, blah,  blah, that we assume it is 
automatic in new users, when, in fact,
it may not necessarily be useful or relevant anymore. Especially, if, 
unlike people like Bill Atkinson,
we don't come from a culture where we stack our pancakes up into one big 
pile and "stuff our mushes", nor play cards on a regular basis.


My Granny, from Carnoustie via Dundee, used to impose a horribly boring 
card game on my sister
and I every time she came to visit, called "Sevens", and whenever she 
was in danger of losing
announce, "Ach, I've got a hand like a sweaty foot." Which put me off 
cards almost completely.


Now; it does seem sensible to call things that sit on cards (buttons, 
images, fields, et al) 'objects',
because, frankly, not all of them CONTROL things: surely, only things 
that contain scripts CONTROL things?


To illustrate how daft calling things on cards 'controls' is, imagine 
calling the black (or white) blotches
on a Frisian cow "organs", when they are so obviously different from 
things such as mouths, eyes, ears

and udders.

Now, undoubtedly, SOME objects may become controls (by being gifted 
scripts), but that's beside
the point when one shows a bunch of learners (whether they are either 9 
or 83 years old,
or anywhere in between) a collections of things (buttons, images, 
fields, et al) on a card, as they have
not yet become controls as they have not had scripts written into their 
scriptEditor windows.


I wonder if it might not be a good idea to get a load of 9 year old 
native speakers to sit down in front
of a VDU displaying a Livecode 'page' containing a load of 'objects' and 
ask those children what they

would call them as a group of things.

Certainly, what ever "those things" are called, the apparent conflict in 
the Dictionary between the "Obj"
 words and the "Controls" mentioned in the Menus does cause confusion 
in young minds (and it may in

 others for all I know).

So, for learning purposes at least, I would say "B*gger the official 
terms", what is needed is a coherent

set of terms for end-users.

Richmond.


___
use-livecode mailing list
use-livecode@lists.runrev.com
Please visit this url to subscribe, unsubscribe and manage your subscription 
preferences:
http://lists.runrev.com/mailman/listinfo/use-livecode

RE: Control? Object?

[FlexibleLearning.com]

To me the terms "control" and "object" are synonymous. When someone talks of
"controls" I immediately assume they come from a C+ background, whereas if
they refer to "objects" I feel more at home.  On the other hand, "the number
of controls" is standard syntax and "the number of objects" throws an error.

However, is a card or stack an "object"? The word "canvas" has started to
appear recently which I find a bit disconcerting!

Hugh Senior
FLCo

> I am currently teaching some children Livecode programming and ran into
> some difficulty
> on Friday when a child asked me why the menus were full of the word
> "Control"
> when I had been talking about "Objects".
> 
> Well?
> 
> How about changing every use of the word "Control" to "Object"?
> 
> Enhancement Request 17879
> 
> Richmond.


___
use-livecode mailing list
use-livecode@lists.runrev.com
Please visit this url to subscribe, unsubscribe and manage your subscription 
preferences:
http://lists.runrev.com/mailman/listinfo/use-livecode

Re: Control? Object?

[Earthednet-wp]

Richmond makes excellent points. I am an experienced programmer, but have often 
scratched my head (as a relative newby) about whether to call a livecode thingy 
an object, a control, or whatever.

For the future of livecode, it is vital that the dictionary, and other 
documentation and tutorials, somehow address issues that newbies face. I've 
been in groups developing a software system that is intended for wide adoption 
(digital library intended for educators, for example) and they study the user 
experience using videos and eye tracking to design the interface. Obviously, 
this is beyond the scope of the livecode team. But the point I want to make is 
that the input from folks like Richmond, who can directly observe (and more 
importantly, interpret) the challenges that new users experience, is extremely 
valuable.

So Thanks to Richmond for his input about the new by experience.
Best,
Bill

William Prothero
http://es.earthednet.org

> On Jun 19, 2016, at 7:56 AM, Richmond  wrote:
> 
> Or, put it another way:
> 
> Maybe I'm just grasping for a consistent way to talk about things in Livecode
> to young children . . ..
> 
> Richmond.
> 
>> On 19.06.2016 17:47, Richmond wrote:
>> "My goal" is to get young children interested in programming computers, and 
>> so that those
>> who have more than a passing interest generated by the classes can continue 
>> by themselves.
>> 
>> There are 3 things that have to be considered in "my goal":
>> 
>> 1. Those kids who continue rely fairly heavily on what they find in the 
>> Dictionary (which can be confusing).
>> 
>> 2. Those kids are neither native speakers of English (nor, frankly, does 
>> Bulgarian contain obvious cognates as do languages such as Vlaams, 
>> Nederlaans, Frisian, Platt-Deutsch or Doric Scots), nor is their standard of 
>> English at anywhere near a near-native like competence.
>> 
>> 3. While, with Primary-level children, an element of simplification has to 
>> take place, I have no
>> desire to dumb-down things to such an extent that those children who wish to 
>> to extend their skills
>> with Livecode (or other programming languages) are unable to owning to a 
>> mis-match between the way I have presented Livecode and what they find "out 
>> in the wild".
>> 
>> Richmond.
>> 
>>> On 19.06.2016 17:32, Mark Schonewille wrote:
>>> If your goal is to teach computer science, you really should stop calling 
>>> controls objects, but if your goal is to teach LiveCode, perhaps it would 
>>> be easier for them to use the word object for now.
>>> 
>>> -- 
>>> Kind regards,
>>> 
>>> Mark Schonewille
>>> Economy-x-Talk
>>> Http://economy-x-talk.com
>>> 
>>> Share the clipboard of your computer over a local network with Clipboard 
>>> Link http://clipboardlink.economy-x-talk.com
>>> 
>>> 
 Op 19 jun. 2016 om 16:28 heeft Richmond  het 
 volgende geschreven:
 
 So:
 
 Should I stop using the word 'Object' for Buttons, Fields and so on while
 teaching children, and make sure I refer to all of those things as 
 'Controls'; even if only
 for the simple reason that the menus keep referring to 'Controls'?
 
 Richmond.
 
> On 19.06.2016 10:19, Richmond wrote:
> I am currently teaching some children Livecode programming and ran into 
> some difficulty
> on Friday when a child asked me why the menus were full of the word 
> "Control"
> when I had been talking about "Objects".
> 
> Well?
> 
> How about changing every use of the word "Control" to "Object"?
> 
> Enhancement Request 17879
> 
> Richmond.
 
 ___
 use-livecode mailing list
 use-livecode@lists.runrev.com
 Please visit this url to subscribe, unsubscribe and manage your 
 subscription preferences:
 http://lists.runrev.com/mailman/listinfo/use-livecode
>>> ___
>>> use-livecode mailing list
>>> use-livecode@lists.runrev.com
>>> Please visit this url to subscribe, unsubscribe and manage your 
>>> subscription preferences:
>>> http://lists.runrev.com/mailman/listinfo/use-livecode
> 
> 
> ___
> use-livecode mailing list
> use-livecode@lists.runrev.com
> Please visit this url to subscribe, unsubscribe and manage your subscription 
> preferences:
> http://lists.runrev.com/mailman/listinfo/use-livecode


___
use-livecode mailing list
use-livecode@lists.runrev.com
Please visit this url to subscribe, unsubscribe and manage your subscription 
preferences:
http://lists.runrev.com/mailman/listinfo/use-livecode

Re: Control? Object?

[Richmond]

Or, put it another way:

Maybe I'm just grasping for a consistent way to talk about things in 
Livecode

to young children . . ..

Richmond.

On 19.06.2016 17:47, Richmond wrote:
"My goal" is to get young children interested in programming 
computers, and so that those
who have more than a passing interest generated by the classes can 
continue by themselves.


There are 3 things that have to be considered in "my goal":

1. Those kids who continue rely fairly heavily on what they find in 
the Dictionary (which can be confusing).


2. Those kids are neither native speakers of English (nor, frankly, 
does Bulgarian contain obvious cognates as do languages such as 
Vlaams, Nederlaans, Frisian, Platt-Deutsch or Doric Scots), nor is 
their standard of English at anywhere near a near-native like competence.


3. While, with Primary-level children, an element of simplification 
has to take place, I have no
desire to dumb-down things to such an extent that those children who 
wish to to extend their skills
with Livecode (or other programming languages) are unable to owning to 
a mis-match between the way I have presented Livecode and what they 
find "out in the wild".


Richmond.

On 19.06.2016 17:32, Mark Schonewille wrote:
If your goal is to teach computer science, you really should stop 
calling controls objects, but if your goal is to teach LiveCode, 
perhaps it would be easier for them to use the word object for now.


--
Kind regards,

Mark Schonewille
Economy-x-Talk
Http://economy-x-talk.com

Share the clipboard of your computer over a local network with 
Clipboard Link http://clipboardlink.economy-x-talk.com



Op 19 jun. 2016 om 16:28 heeft Richmond  
het volgende geschreven:



So:

Should I stop using the word 'Object' for Buttons, Fields and so on 
while
teaching children, and make sure I refer to all of those things as 
'Controls'; even if only

for the simple reason that the menus keep referring to 'Controls'?

Richmond.

On 19.06.2016 10:19, Richmond wrote:
I am currently teaching some children Livecode programming and ran 
into some difficulty
on Friday when a child asked me why the menus were full of the word 
"Control"

when I had been talking about "Objects".

Well?

How about changing every use of the word "Control" to "Object"?

Enhancement Request 17879

Richmond.


___
use-livecode mailing list
use-livecode@lists.runrev.com
Please visit this url to subscribe, unsubscribe and manage your 
subscription preferences:

http://lists.runrev.com/mailman/listinfo/use-livecode

___
use-livecode mailing list
use-livecode@lists.runrev.com
Please visit this url to subscribe, unsubscribe and manage your 
subscription preferences:

http://lists.runrev.com/mailman/listinfo/use-livecode





___
use-livecode mailing list
use-livecode@lists.runrev.com
Please visit this url to subscribe, unsubscribe and manage your subscription 
preferences:
http://lists.runrev.com/mailman/listinfo/use-livecode

Re: Control? Object?

[Richmond]

"My goal" is to get young children interested in programming computers, 
and so that those
who have more than a passing interest generated by the classes can 
continue by themselves.


There are 3 things that have to be considered in "my goal":

1. Those kids who continue rely fairly heavily on what they find in the 
Dictionary (which can be confusing).


2. Those kids are neither native speakers of English (nor, frankly, does 
Bulgarian contain obvious cognates as do languages such as Vlaams, 
Nederlaans, Frisian, Platt-Deutsch or Doric Scots), nor is their 
standard of English at anywhere near a near-native like competence.


3. While, with Primary-level children, an element of simplification has 
to take place, I have no
desire to dumb-down things to such an extent that those children who 
wish to to extend their skills
with Livecode (or other programming languages) are unable to owning to a 
mis-match between the way I have presented Livecode and what they find 
"out in the wild".


Richmond.

On 19.06.2016 17:32, Mark Schonewille wrote:

If your goal is to teach computer science, you really should stop calling 
controls objects, but if your goal is to teach LiveCode, perhaps it would be 
easier for them to use the word object for now.

--
Kind regards,

Mark Schonewille
Economy-x-Talk
Http://economy-x-talk.com

Share the clipboard of your computer over a local network with Clipboard Link 
http://clipboardlink.economy-x-talk.com


Op 19 jun. 2016 om 16:28 heeft Richmond  het 
volgende geschreven:


So:

Should I stop using the word 'Object' for Buttons, Fields and so on while
teaching children, and make sure I refer to all of those things as 'Controls'; 
even if only
for the simple reason that the menus keep referring to 'Controls'?

Richmond.

On 19.06.2016 10:19, Richmond wrote:

I am currently teaching some children Livecode programming and ran into some 
difficulty
on Friday when a child asked me why the menus were full of the word "Control"
when I had been talking about "Objects".

Well?

How about changing every use of the word "Control" to "Object"?

Enhancement Request 17879

Richmond.


___
use-livecode mailing list
use-livecode@lists.runrev.com
Please visit this url to subscribe, unsubscribe and manage your subscription 
preferences:
http://lists.runrev.com/mailman/listinfo/use-livecode

___
use-livecode mailing list
use-livecode@lists.runrev.com
Please visit this url to subscribe, unsubscribe and manage your subscription 
preferences:
http://lists.runrev.com/mailman/listinfo/use-livecode



___
use-livecode mailing list
use-livecode@lists.runrev.com
Please visit this url to subscribe, unsubscribe and manage your subscription 
preferences:
http://lists.runrev.com/mailman/listinfo/use-livecode

Re: Control? Object?

[Mark Schonewille]

If your goal is to teach computer science, you really should stop calling 
controls objects, but if your goal is to teach LiveCode, perhaps it would be 
easier for them to use the word object for now. 

--
Kind regards,

Mark Schonewille
Economy-x-Talk
Http://economy-x-talk.com

Share the clipboard of your computer over a local network with Clipboard Link 
http://clipboardlink.economy-x-talk.com


Op 19 jun. 2016 om 16:28 heeft Richmond  het 
volgende geschreven:

> So:
> 
> Should I stop using the word 'Object' for Buttons, Fields and so on while
> teaching children, and make sure I refer to all of those things as 
> 'Controls'; even if only
> for the simple reason that the menus keep referring to 'Controls'?
> 
> Richmond.
> 
> On 19.06.2016 10:19, Richmond wrote:
>> I am currently teaching some children Livecode programming and ran into some 
>> difficulty
>> on Friday when a child asked me why the menus were full of the word "Control"
>> when I had been talking about "Objects".
>> 
>> Well?
>> 
>> How about changing every use of the word "Control" to "Object"?
>> 
>> Enhancement Request 17879
>> 
>> Richmond.
> 
> 
> ___
> use-livecode mailing list
> use-livecode@lists.runrev.com
> Please visit this url to subscribe, unsubscribe and manage your subscription 
> preferences:
> http://lists.runrev.com/mailman/listinfo/use-livecode

___
use-livecode mailing list
use-livecode@lists.runrev.com
Please visit this url to subscribe, unsubscribe and manage your subscription 
preferences:
http://lists.runrev.com/mailman/listinfo/use-livecode

Re: Control? Object?

[Richmond]

So:

Should I stop using the word 'Object' for Buttons, Fields and so on while
teaching children, and make sure I refer to all of those things as 
'Controls'; even if only

for the simple reason that the menus keep referring to 'Controls'?

Richmond.

On 19.06.2016 10:19, Richmond wrote:
I am currently teaching some children Livecode programming and ran 
into some difficulty
on Friday when a child asked me why the menus were full of the word 
"Control"

when I had been talking about "Objects".

Well?

How about changing every use of the word "Control" to "Object"?

Enhancement Request 17879

Richmond.



___
use-livecode mailing list
use-livecode@lists.runrev.com
Please visit this url to subscribe, unsubscribe and manage your subscription 
preferences:
http://lists.runrev.com/mailman/listinfo/use-livecode

Re: Control? Object?

[Richard Gaskin]

Mark Schonewille wrote:


In my book, I consistently distinguish objects and controls. This means
that I almost always talk about controls and very rarely about objects,
because it isn't really necessary to use objects in the LiveCode
scripting language


Sounds like a good approach, since as you describe the two words mean 
different things, controls being a subset of objects.




and AFAIK there is no "create object" command in the
LiveCode language  (but if you really want to, you can simulate objects).


There is no "create control" command either.  Controls are a subset of 
objects, and since every *thing* in LiveCode is an object, with the 
create command the "object" is inherently implied in the act of 
creation.  With this implication, "object" isn't needed any more than 
"control" would be; what we need to let it know is the type of object we 
want to create, e.g.


   create button
   create stack



It is interesting that LiveCode (I'm working with 6.7.6 today) doesn't
have an "object" keyword but does have a "control" keyword, while many
functions, commands and messages contain either the string "control" or
the string "object".


The control keyword is most useful for counting or stepping through 
controls on a card object. e.g.:


   the number of controls

Since objects are a superset that would include all structural elements, 
this:


   the number of objects

...should not be synonymous, but instead have a higher count that 
includes cards, substacks, perhaps even audioClips, etc.


I can conceive of a few use cases for an "objects" keyword, but only 
very few.  If anyone here feels strongly this should be included, please 
let us know the RQCC # of your request so we can follow its progress.




It is clear that LiveCode hasn't matured well enough to deal with this
issue. I would recommend using above definitions consistently. One day,
real objects will be introduced into the LiveCode scripting language and
we will need to distinguish them from controls.


I've long advocated adopting OOP as an optional set of extensions to the 
language, and IIRC have been informed that it'll likely never happen. 
I'll leave it to Mark Waddingham to explain why.


But in the meantime, just because LC doesn't conform specifically to OOP 
conventions doesn't mean its objects don't exist.  OOP is one 
implementation of object-based systems.  XTalks are another.


Given both their age and very intentional design, I'm not sure I would 
use "less mature" to distinguish xTalks from systems that are merely 
different.


--
 Richard Gaskin
 Fourth World Systems
 Software Design and Development for Desktop, Mobile, and Web
 
 ambassa...@fourthworld.comhttp://www.FourthWorld.com

___
use-livecode mailing list
use-livecode@lists.runrev.com
Please visit this url to subscribe, unsubscribe and manage your subscription 
preferences:
http://lists.runrev.com/mailman/listinfo/use-livecode

Re: Control? Object?

[Richard Gaskin]

Richmond wrote:

> So there is no question of 'reserved words'; there is a simple case
> of a state of BAD confusion that needs to be sorted out, 2 words
> being used for one thing, or, rather one set of things:
>
> either:
>
> 1. Dump the word 'object' and only use 'control', or
>
> 2. Dump the word 'control' and only use 'object'.

...or:

3. Recognize that controls are a subset of objects and move on to worry 
about more interesting things.


All birds are animals, but not all animals are birds.

Objects are software nouns, and controls are the subset of those nouns 
that you can directly manipulate, or, if you will, "control".


--
 Richard Gaskin
 Fourth World Systems
 Software Design and Development for Desktop, Mobile, and Web
 
 ambassa...@fourthworld.comhttp://www.FourthWorld.com


___
use-livecode mailing list
use-livecode@lists.runrev.com
Please visit this url to subscribe, unsubscribe and manage your subscription 
preferences:
http://lists.runrev.com/mailman/listinfo/use-livecode

Re: Control? Object?

[me]

Well said, Mark!

Best, Jerry

On Jun 19, 2016, 7:23 AM -0500, Mark 
Schonewille, wrote:
> Hi Richmond,
> 
> The LiveCode documentation consistently talks about objects, where this
> should be controls. The scripting language, however, mixes up the two
> concepts completely.
> 
> An object is a collection of properties and instructions defined by a
> programming syntax (where one shouldn't limit "programming syntax" to
> the traditional text listings but also include "syntax" created by
> visual programming environments).
> 
> A control is an often visual component of an interface, which allows the
> user to interact with the program, such as a button, a field and a slider.
> 
> Objects can create controls, but objects may also perform other tasks,
> such as saving data to disk, creating arrays, moving a control, and many
> other tasks.
> 
> In my book, I consistently distinguish objects and controls. This means
> that I almost always talk about controls and very rarely about objects,
> because it isn't really necessary to use objects in the LiveCode
> scripting language and AFAIK there is no "create object" command in the
> LiveCode language (but if you really want to, you can simulate objects).
> 
> It is interesting that LiveCode (I'm working with 6.7.6 today) doesn't
> have an "object" keyword but does have a "control" keyword, while many
> functions, commands and messages contain either the string "control" or
> the string "object".
> 
> It is clear that LiveCode hasn't matured well enough to deal with this
> issue. I would recommend using above definitions consistently. One day,
> real objects will be introduced into the LiveCode scripting language and
> we will need to distinguish them from controls.
> 
> Kind regards,
> 
> Mark Schonewille
> http://economy-x-talk.com
> https://www.facebook.com/marksch
> 
> Buy the most extensive book on the
> LiveCode language:
> http://livecodebeginner.economy-x-talk.com
> 
> Op 19-Jun-16 om 09:19 schreef Richmond:
> > I am currently teaching some children Livecode programming and ran into
> > some difficulty
> > on Friday when a child asked me why the menus were full of the word
> > "Control"
> > when I had been talking about "Objects".
> > 
> > Well?
> > 
> > How about changing every use of the word "Control" to "Object"?
> > 
> > Enhancement Request 17879
> > 
> > Richmond.
> > 
> > ___
> > use-livecode mailing list
> > use-livecode@lists.runrev.com
> > Please visit this url to subscribe, unsubscribe and manage your
> > subscription preferences:
> > http://lists.runrev.com/mailman/listinfo/use-livecode
> 
> ___
> use-livecode mailing list
> use-livecode@lists.runrev.com
> Please visit this url to subscribe, unsubscribe and manage your subscription 
> preferences:
> http://lists.runrev.com/mailman/listinfo/use-livecode
___
use-livecode mailing list
use-livecode@lists.runrev.com
Please visit this url to subscribe, unsubscribe and manage your subscription 
preferences:
http://lists.runrev.com/mailman/listinfo/use-livecode

Re: Control? Object?

[Mark Schonewille]

Hi Richmond,

The LiveCode documentation consistently talks about objects, where this 
should be controls. The scripting language, however, mixes up the two 
concepts completely.


An object is a collection of properties and instructions defined by a 
programming syntax (where one shouldn't limit "programming syntax" to 
the traditional text listings but also include "syntax" created by 
visual programming environments).


A control is an often visual component of an interface, which allows the 
user to interact with the program, such as a button, a field and a slider.


Objects can create controls, but objects may also perform other tasks, 
such as saving data to disk, creating arrays, moving a control, and many 
other tasks.


In my book, I consistently distinguish objects and controls. This means 
that I almost always talk about controls and very rarely about objects, 
because it isn't really necessary to use objects in the LiveCode 
scripting language and AFAIK there is no "create object" command in the 
LiveCode language  (but if you really want to, you can simulate objects).


It is interesting that LiveCode (I'm working with 6.7.6 today) doesn't 
have an "object" keyword but does have a "control" keyword, while many 
functions, commands and messages contain either the string "control" or 
the string "object".


It is clear that LiveCode hasn't matured well enough to deal with this 
issue. I would recommend using above definitions consistently. One day, 
real objects will be introduced into the LiveCode scripting language and 
we will need to distinguish them from controls.


Kind regards,

Mark Schonewille
http://economy-x-talk.com
https://www.facebook.com/marksch

Buy the most extensive book on the
LiveCode language:
http://livecodebeginner.economy-x-talk.com

Op 19-Jun-16 om 09:19 schreef Richmond:

I am currently teaching some children Livecode programming and ran into
some difficulty
on Friday when a child asked me why the menus were full of the word
"Control"
when I had been talking about "Objects".

Well?

How about changing every use of the word "Control" to "Object"?

Enhancement Request 17879

Richmond.

___
use-livecode mailing list
use-livecode@lists.runrev.com
Please visit this url to subscribe, unsubscribe and manage your
subscription preferences:
http://lists.runrev.com/mailman/listinfo/use-livecode


___
use-livecode mailing list
use-livecode@lists.runrev.com
Please visit this url to subscribe, unsubscribe and manage your subscription 
preferences:
http://lists.runrev.com/mailman/listinfo/use-livecode

Re: Control? Object?

[dunbarx]

Whatever we might wish for, "objects" in and of itself does not exist in LC. It 
is just a mental construct, a remnant of HC days. I think that way, too, but 
also know that:


You cannot: "answer the number of objects."


though you surely can: "answer the number of controls"


I doubt the team would think this very important.


Craig Newman




-Original Message-
From: Richmond <richmondmathew...@gmail.com>
To: How to use LiveCode <use-livecode@lists.runrev.com>
Sent: Sun, Jun 19, 2016 6:44 am
Subject: Re: Control? Object?

If 'Object' is a reserved word, then why is the Dictionary "we all know 
and love" full of 'objects':

errorObject
focusedObject
menuObject
objectSelectionEnded
objectSelectionStarted
selectedObjectChanged
selectedObject
selectedObjects
selObj
selObjs ?

Looking up 'focusedObject' one can read:

"Returns the currently focused control"

So there is no question of 'reserved words'; there is a simple case of a 
state of
BAD confusion that needs to be sorted out, 2 words being used for one 
thing, or, rather
one set of things:

either:

1. Dump the word 'object' and only use 'control', or

2. Dump the word 'control' and only use 'object'.

Personally I prefer #2.

This is an "issue" [ a.k.a. 'fudge' ] that has been left unfixed for 
far, far too long.

Presumably (?) this is something that can be sorted out pretty quickly 
using search-and-replace.

Richmond.


On 19.06.2016 11:03, David Bovill wrote:
> I have the same issue :)
>
> I started a long time ago to name handlers with the concept of "object"
> rather than "control" - it was more intuitive. The word "object" has
> associations for the new user which makes it easier to grasp the related
> concepts of "property" and so forth. Livecode is rooted in the
> object-oriented paradigm of small-talk, and HyperCard - and many of the
> concepts such a "stack", "card" and "field" etc are layered on top of this
> metaphor. The problem is that they are not pure objects in a technical
> sense, and the term is sort of reserved for a possible future expansion of
> the vocabulary. I am not sure if this will ever happen, and in the mean
> time we are left with a clear metaphor, and a confusing reality. I've
> decided to live with it :)
>
> So when I refer to a "field" in a variable I use "fieldObject" rather than
> "fieldControl", or with a virtual property I use "put the field_Object of
> this card..." rather than "field_Control". This is partly because i don;t
> want to confuse (myself) and other readers with a terminology that sound
> too much like Model View Controller architecture - or the idea that you are
> "doing something" ie "controlling" the concept in question.
>
> So my answer is that while creating an abstraction in how I code, I name
> things using the best metaphor I can find, so often I will think in terms
> of concrete objects, with properties that may or may not be implemented
> with a "control", a "group", or more recently a "widget". The most abstract
> concept is "object" which can refer to any of those - but I try to avoid it
> where possible and use a more explicit name of the term "view" - so
> "textView" or "the index_View of this card".
>
> On 19 June 2016 at 08:19, Richmond <richmondmathew...@gmail.com> wrote:
>
>> I am currently teaching some children Livecode programming and ran into
>> some difficulty
>> on Friday when a child asked me why the menus were full of the word
>> "Control"
>> when I had been talking about "Objects".
>>
>> Well?
>>
>> How about changing every use of the word "Control" to "Object"?
>>
>> Enhancement Request 17879
>>
>> Richmond.
>>
>> ___
>> use-livecode mailing list
>> use-livecode@lists.runrev.com
>> Please visit this url to subscribe, unsubscribe and manage your
>> subscription preferences:
>> http://lists.runrev.com/mailman/listinfo/use-livecode
>>
> ___
> use-livecode mailing list
> use-livecode@lists.runrev.com
> Please visit this url to subscribe, unsubscribe and manage your subscription 
> preferences:
> http://lists.runrev.com/mailman/listinfo/use-livecode


___
use-livecode mailing list
use-livecode@lists.runrev.com
Please visit this url to subscribe, unsubscribe and manage your subscription 
preferences:
http://lists.runrev.com/mailman/listinfo/use-livecode


___
use-livecode mailing list
use-livecode@lists.runrev.com
Please visit this url to subscribe, unsubscribe and manage your subscription 
preferences:
http://lists.runrev.com/mailman/listinfo/use-livecode

Re: Control? Object?

[Richmond]

If 'Object' is a reserved word, then why is the Dictionary "we all know 
and love" full of 'objects':


errorObject
focusedObject
menuObject
objectSelectionEnded
objectSelectionStarted
selectedObjectChanged
selectedObject
selectedObjects
selObj
selObjs  ?

Looking up 'focusedObject' one can read:

"Returns the currently focused control"

So there is no question of 'reserved words'; there is a simple case of a 
state of
BAD confusion that needs to be sorted out, 2 words being used for one 
thing, or, rather

one set of things:

either:

1. Dump the word 'object' and only use 'control', or

2. Dump the word 'control' and only use 'object'.

Personally I prefer #2.

This is an "issue" [ a.k.a. 'fudge' ] that has been left unfixed for 
far, far too long.


Presumably (?) this is something that can be sorted out pretty quickly 
using search-and-replace.


Richmond.


On 19.06.2016 11:03, David Bovill wrote:

I have the same issue :)

I started a long time ago to name handlers with the concept of "object"
rather than "control" - it was more intuitive. The word "object" has
associations for the new user which makes it easier to grasp the related
concepts of "property" and so forth. Livecode is rooted in the
object-oriented paradigm of small-talk, and HyperCard - and many of the
concepts such a "stack", "card" and "field" etc are layered on top of this
metaphor. The problem is that they are not pure objects in a technical
sense, and the term is sort of reserved for a possible future expansion of
the vocabulary. I am not sure if this will ever happen, and in the mean
time we are left with a clear metaphor, and a confusing reality. I've
decided to live with it :)

So when I refer to a "field" in a variable I use "fieldObject" rather than
"fieldControl", or with a virtual property I use "put the field_Object of
this card..." rather than "field_Control". This is partly because i don;t
want to confuse (myself) and other readers with a terminology that sound
too much like Model View Controller architecture - or the idea that you are
"doing something" ie "controlling" the concept in question.

So my answer is that while creating an abstraction in how I code, I name
things using the best metaphor I can find, so often I will think in terms
of concrete objects, with properties that may or may not be implemented
with a "control", a "group", or more recently a "widget". The most abstract
concept is "object" which can refer to any of those - but I try to avoid it
where possible and use a more explicit name of the term "view" - so
"textView" or "the index_View of this card".

On 19 June 2016 at 08:19, Richmond  wrote:


I am currently teaching some children Livecode programming and ran into
some difficulty
on Friday when a child asked me why the menus were full of the word
"Control"
when I had been talking about "Objects".

Well?

How about changing every use of the word "Control" to "Object"?

Enhancement Request 17879

Richmond.

___
use-livecode mailing list
use-livecode@lists.runrev.com
Please visit this url to subscribe, unsubscribe and manage your
subscription preferences:
http://lists.runrev.com/mailman/listinfo/use-livecode


___
use-livecode mailing list
use-livecode@lists.runrev.com
Please visit this url to subscribe, unsubscribe and manage your subscription 
preferences:
http://lists.runrev.com/mailman/listinfo/use-livecode



___
use-livecode mailing list
use-livecode@lists.runrev.com
Please visit this url to subscribe, unsubscribe and manage your subscription 
preferences:
http://lists.runrev.com/mailman/listinfo/use-livecode

Re: Control? Object?

[David Bovill]

I have the same issue :)

I started a long time ago to name handlers with the concept of "object"
rather than "control" - it was more intuitive. The word "object" has
associations for the new user which makes it easier to grasp the related
concepts of "property" and so forth. Livecode is rooted in the
object-oriented paradigm of small-talk, and HyperCard - and many of the
concepts such a "stack", "card" and "field" etc are layered on top of this
metaphor. The problem is that they are not pure objects in a technical
sense, and the term is sort of reserved for a possible future expansion of
the vocabulary. I am not sure if this will ever happen, and in the mean
time we are left with a clear metaphor, and a confusing reality. I've
decided to live with it :)

So when I refer to a "field" in a variable I use "fieldObject" rather than
"fieldControl", or with a virtual property I use "put the field_Object of
this card..." rather than "field_Control". This is partly because i don;t
want to confuse (myself) and other readers with a terminology that sound
too much like Model View Controller architecture - or the idea that you are
"doing something" ie "controlling" the concept in question.

So my answer is that while creating an abstraction in how I code, I name
things using the best metaphor I can find, so often I will think in terms
of concrete objects, with properties that may or may not be implemented
with a "control", a "group", or more recently a "widget". The most abstract
concept is "object" which can refer to any of those - but I try to avoid it
where possible and use a more explicit name of the term "view" - so
"textView" or "the index_View of this card".

On 19 June 2016 at 08:19, Richmond  wrote:

> I am currently teaching some children Livecode programming and ran into
> some difficulty
> on Friday when a child asked me why the menus were full of the word
> "Control"
> when I had been talking about "Objects".
>
> Well?
>
> How about changing every use of the word "Control" to "Object"?
>
> Enhancement Request 17879
>
> Richmond.
>
> ___
> use-livecode mailing list
> use-livecode@lists.runrev.com
> Please visit this url to subscribe, unsubscribe and manage your
> subscription preferences:
> http://lists.runrev.com/mailman/listinfo/use-livecode
>
___
use-livecode mailing list
use-livecode@lists.runrev.com
Please visit this url to subscribe, unsubscribe and manage your subscription 
preferences:
http://lists.runrev.com/mailman/listinfo/use-livecode

Control? Object?

[Richmond]

I am currently teaching some children Livecode programming and ran into 
some difficulty
on Friday when a child asked me why the menus were full of the word 
"Control"

when I had been talking about "Objects".

Well?

How about changing every use of the word "Control" to "Object"?

Enhancement Request 17879

Richmond.

___
use-livecode mailing list
use-livecode@lists.runrev.com
Please visit this url to subscribe, unsubscribe and manage your subscription 
preferences:
http://lists.runrev.com/mailman/listinfo/use-livecode