What is the best way to learn LiveCode?

[uelandbob]

What are the best resources to learn LiveCode?

What I would like to have are lessons that teach how to manipulate various objects with commands. Kind of Lego so that I can make my own app using those components. I'm primarily not interested in learning how to make whole projects, because these tend to be complex and target things I may not be interested in. What would be especially valuable is a walkthrough of the various system messages (those found when you click on Dictionary/Language/Message). It seems to be about 250 of them.

I have seen
lessons . runrev . com

I have also read that one of the best way to learn stuff is to try it out, using the dictionary for hints.
That is not so easy since I do not know where to begin, what is important what is less important, and so on. I know that you can learn anything with blood, sweat and tears, but I think that LiveCode aims to give programming power to non programmers, so we should make the learning curve little gentler.

What I'm missing is a MODEL for the LC and the SYSTEMATIC WAY OF LEARNING LC. I would like to have big picture of the engine, what messages it sends, how my handlers can trap them. How do stack works with engine and how do they work with each other. Is my app limited to having one stack or can it be multi-stack? Are these stacks organized in a hierarchy or in some other formation.
What objects can be manipulates and in what ways.

When a message is sent to an object and not trapped by it, where does that message go? What does the message path look like?
In one of the posts here at forum I found a link to Richard Gaskin's excellent article called

Extending the LiveCode Message Path
(google to find it)

That is the kind of resources I'm talking about!

What I would also like to know are the limits of LC. For instance can it make a simple animation of drawing a line or a circle. Because if I plan to write an animatable version of Euclides Elements for my math class, those two things are essential. Or if I'm making an iOS game then what are the limitations?

If there are such learning resources, I would like to know where to find them. If there aren't, then I (maybe together with others) could invest some time to create it. But only if there is a need ....

[richmond62]

If you want to draw animated geometrical tiddley-poms in Livecode you
could do far worse than have a go with my "SPIRO" stack:

https://www.dropbox.com/sh/ja47l87gg87s ... C5ORa?dl=0

File "spiro.lc.zip"

[dunbarx]

You are articulate in your query.

But it will be difficult to learn LC based on a directed subset of usage, whatever that may entail. That is because foundational knowledge is common to, and required for, all endeavors, Certainly 95% of the dictionary can be ignored once you have this, but there is no subset of the language that can be set aside to make that number 99%. Note that 99% is about twenty language elements. You will need at least 50, and knowing which 50 beforehand is not easy.

So learn the basics, and only then will you be able to filter for yourself what you can concentrate on.

Craig Newman

[uelandbob]

That is because foundational knowledge is common to, and required for, all endeavors...
Note that 99% is about twenty language elements...
So learn the basics...
Craig Newman

Thank you Craig, good observations . Could you be little more specific

1. What exactly do you consider the foundational knowledge?

2. What 20 language elements are that? I'm very interested!

3. What according to you are the basics?

[dunbarx]

Hmmm.

You need to know that an xTalk, like LC, is an environment where messages are sent and trapped.

You need to know the difference between commands, functions and properties. You need to know what the message path is. Only then can you add the few dozen or so other language elements and make sense of how they live in that environment. It cannot be done is a few weeks. But it can be done in a few months. Write back here often.

Oh yes, you need the "put" command.

Craig

[Martin Koob]

I agree with Craig, the message path is the foundational thing to get a handle on. If you came to LiveCode(or Runtime Revolution) from HyperCard is was already in your DNA. If you come from another language you probably have to take some time to get your head around it, how messages travel through the message path and how to circumvent the regular message path by sending or dispatching messages. As you said Richard Gaskin has a good explanation of the message path and also how to extend it. That includes adding other stacks to a project as you mentioned in your message with the start using command.

http://www.fourthworld.com/embassy/arti ... _path.html

He also created a tutorial stack as a part of some LiveCode/Revolution scripting conferences. This includes some demos so you can see how it works in practice.

http://www.hyperactivesw.com/revscriptc ... ences.html

In the scripting conferences there are other topics that would be good to have a good foundation in.

Martin

[FourthWorld]

What I'm missing is a MODEL for the LC and the SYSTEMATIC WAY OF LEARNING LC.

The 378-page User Guide is a great place to start, available through the IDE's Help menu.

How much of that have you read?

Given the breadth of things LiveCode is used for, once we get past the basics the path to learning the things most relevant to a given learner will vary. So after you've gotten what you find useful in the User Guide, drop in here with any questions you have and we'll point you to the resources to get you moving along powerfully.

[uelandbob]

1. ... messages are sent and trapped.
2. ... difference between commands, functions and properties.
3. ... what the message path is.
4. ... you need the "put" command.
Craig

Thank you Craig

Yes I agree that those are good starting points...

1. Yes LC consists of "objects" like button, field, card, stack and so on that all can send messages to each other. And let's not forget the LiveCode engine itself which is the biggest message generator of all. As soon as user does something like click a mouse or press a key the engine sends messages (to predetermined objects depending on the actual situation). Those messages are different from the messages that your handler sends, because you control latter, but not the former. The distinction between the system messages and your own messages is important one, and if you do not understand the difference, LC will always be a a mysterious creature.

Knowing the existence of various system messages is one of the key skills, because if you do not know that a certain system message exists, you can't trap it. For instance if you don't know that preOpenStack is generated before the stack window appears, you will not think of possibility to adjusts the size, position, and appearance of objects before the stack appears.

Objects also have properties. To know which properties an object has and how you can change them, is an important skill. Also here if you don't know that a certain object has a property you can't change it. For instance if you do not know that a graphic object has a property called "points" you will not come up with the idea that you can dynamically change that object by changing its points.

2. I found a nice explanation of the difference between commands and functions at
www . hyperactivesw . com / resources_function . html

3. Yes, I agree to 100%. The message path and how it works is one of the most important things to understand.

[Newbie4]

If you would like to explore LiveCode and learn by doing small projects, try here https://sites.google.com/a/pgcps.org/livecode/

[uelandbob]

1. The 378-page User Guide is a great place to start, available through the IDE's Help menu.
How much of that have you read?

2. Given the breadth of things LiveCode is used for, once we get past the basics the path to learning the things most relevant to a given learner will vary.

3. So after you've gotten what you find useful in the User Guide, drop in here with any questions you have and we'll point you to the resources to get you moving along powerfully.

Thanks Richard

1. I've totally missed it. Usually an IDE and the accompanying programming language (like Apple Objective-C, Microsoft Visual Basic, Oracle Java, Wolfram Mathematica) have "the Docs" referring to the mother documentation, where you can get all the answers. Going through them is often painful and what I call learning through blood sweat and tears. They can of course vary, Mathematica's docs are very understandable with a lot of examples, while Apple's are very hard to understand with hardly any examples at all. But what they often miss is the MODEL or what you, Craig and Martin call the basics. I will take a look at User Guide and see if it explains the Model or not.

2. I agree, once you understand the MODEL (the basics) you take different paths.

3. Ah the forum, one of the best fruits of the Internet A great learning resource and a place to make friends

[uelandbob]

1. the message path... If you came to LiveCode from HyperCard is was already in your DNA. If you come from another language you probably have to take some time to get your head around it, how messages travel through the message path and how to circumvent the regular message path by sending or dispatching messages.

2. He also created a tutorial stack as a part of some LiveCode/Revolution scripting conferences. This includes some demos so you can see how it works in practice...

Thanks Martin

1. Many years ago I did my fair share of HyperCard programming so yes I know about the message path. I've also done some Cocoa programming and they have something called the Responder Chain where the idea is similar.

2. Ah a very useful resource!!

LiveCode is not my first programming environment. I've been through many of them, and my idea of learning a new environment is not to read all the "docs". Nor is it to do a set of cute "toy examples", that do not explain the broader picture*. Nor is it to do one "BIG HAIRY EXAMPLE". No, what I'm after is to understand the MODEL, the mechanism that drives the programming environment. What you, Craig and Richard call "the basics". When you know this mechanism you can be unleashed on your own, because you have internalized the "model" and can find your way around.

* On the other hand toy examples that are used to illustrate the MODEL (the mechanism, the basics of programming environment), are very useful.

[uelandbob]

If you would like to explore LiveCode and learn by doing small projects, try here

Thanks , many nice examples

[newtronsols]

I thought I just posted this but..
http://livecode.com/create-it-with-livecode/

[uelandbob]

I know that programming with LC (or HC its predecessor) is vastly easier then Cocoa or iOS. I wonder why? Here are some hypotheses.

1. By attaching the scripts to objects directly brings the developer much closer to the user. The developer uses the Edit tool while the user uses the Run tool. But the user interface is almost the same, which means that the developer can directly make the connection between the user interface and his code.

2. If you have ever programmed in Cocoa you know that setting up the objects and their properties is half the work. When you create an object the first thing you see in the initializer are calls to setup this and setup that. In LC, that setting up is taken care of by the Object Inspector. (I know that Cocoa has the Interface Builder, but it's a far cry from LC ease of use).

3. Cocoa uses traditional object oriented concepts. At first glance the concepts like classes which can be instantiated to objects, and classes which can inherit from other classes, seems a clever idea. Until you see other languages that do not use classes and are much easier to program. The fact is that classes, inheritance and instantiation add much more complexity then they remove. LC is avoiding classes. Like other class less languages it uses clone to make new objects (as opposed to instantiating objects from classes). It is just as powerful as instantiation, without adding unnecessary complexity.

4. LC has the message path, a predefined route where received messages will travel, if not trapped by some object on the path. I think this is a brilliant idea and one of the real secrets behind LC's simplicity.

I would love to hear if there are other aspects I have missed.

[FourthWorld]

uelandbob, your summary is most excellent. If it could fit on a t-shirt I'd wear it at the next LiveCode conference.