Home‎ > ‎

Why LiveCode

Why LiveCode is a Better Choice as a First Language to Learn

From an Educator's Viewpoint

When I mention LiveCode I often get blank stares. They are thinking that it is a cutesy new language like Scratch, Karel or Turtle Graphics. Sometimes they say "That's not a real language, is it?" followed by "We use Python/Java, a real language." 

LiveCode, a descendent of HyperCard, has been around for over ten years and may well be the ideal language to teach introductory programming and associated concepts (computational thinking, logic, problem solving, etc). It is an established language with a corporate, educational and public following. It has the excitement of newer academic languages but with the rigor of Python/Java. It is free, open source and actively being extended.

Efforts are underway to prescribe what and how to teach Computer Science. They are creating new languages to make it easier for all grades. Unfortunately, they are ignoring solid education research that exists, especially in the choice of the languages.

Here are five reasons why I chose LiveCode to teach as their first language:

#1. Build On What Students Already Know

“The first step when learning is to connect to what students already know. Nobody comes to class as a blank slate. Learning is a process of making sense of the world. We "make sense" of new concepts in terms of what we already know. Teachers know and use "Scaffolding" in teaching new concepts to students

“Bruner and decades of cognitive psychology researchers have said that a teacher should relate new material to previously learned materials. The first step is to figure out what the learners already know and care about.”

Students know apps and games. Teach them programming using what they are familiar with. You will have their attention, interest and they will work hard at creating their own. LiveCode makes this easy without succumbing to the drag-n-drop programming schools like Scratch or AppInventor. LiveCode is GUI based and object-oriented but the heart of it is still line-by-line coding and debugging. 

Students know and use cell phones, tablets and laptops. Give them the opportunity to create programs to run on them. Allow them to easily share what they have written with their friends and family. LiveCode runs on all platforms and deploys standalone to all platforms (PC, Apple, Linux, iOS, Android, HTML5/Chromebooks). 

Students also know English. LiveCode commands are very much English-like. With LiveCode, programming is simply a matter of describing what you are going to do in common terms. Think pseudo-code.

#2. Do Not Overwhelm Them

“Human working memory is notoriously small and short-lived. We can only handle seven new digits or five words at time, and even fewer chunks for children and young adults. We underestimate how much cognitive load our modern programming languages require, because as experts in programming, much of our programming knowledge is tacit -- we do it automatically without attending to the details, and without even being aware that we're doing it.

Programming is overwhelming in terms of cognitive loading. Most languages require learning a new vocabulary, basic algebra, logic and strange concepts. 

Some Examples:

1. Variable types:

In most languages, types (byte, int, double, float, char, string, etc) are important and besides getting errors mixing them, you can also get incorrect answers in calculations. You need to know when to use each and how. You have to declare the type upfront and never, ever try to change it or mix them.

In LiveCode type is not a worry. Students do not have to deal with types and worry about mixing them.The simple command is “put b+1 into a” and the necessary conversions will take place. 

2. Comparisons:

In Python, you need to know the difference between x=y+1, x==y+1, x===y+1.  The number of equal signs matter. Assignment statements are different from comparison statements. Java is much the same where x=1 is an assignment statement and x==1 is a compare statement. Students easily confuse them and get frustrated.

In LiveCode, if you want a compare the you say - "is x equal to y+1”? That is it. There is no confusion between the statements: "put 1 into x" and "is x equal to 1".

3. Loops, Lists and Counting:

In most languages (Python,, Java, etc), you start counting with zero and you stop at the total minus one. That is so confusing. Students rarely get past that concept. They get confused with what numbers to use in loops, lists and other calculations. They run into "off by one" errors and mistakingly add one or two. They have trouble indexing - e.g. "January" is month[0] not month[1].

In LiveCode, counting always starts with 1. Lists, arrays and indexes start with 1. There are no problems.

4. Logic 

They have to learn a whole new set of symbols, vocabulary and basic algebra. They have &, &&, |, ||, ! and other symbols to learn (depending on the language). They have to deal with complex logic statements (e.g. "not (a or b) or not a and not b") and ( x=x+1:  x<0 || x>1, for (i=0 ; i<10 ; i++) )  These are necessary to learn but not at the beginning when you are just getting started.

LiveCode accomplishes the same goals but with English ("add 1 to x, if x is less than 0 or more than 1, repeat 10 times").  With LiveCode, the students are ready to start coding. They write what they would say. They do not have to translate it into strange forms.

4. Text Handling 

Doing simple text manipulations can be complex and require prelearning of other concepts and functions. A simple task of deleting the last character of a string stored in a variable (like deleting the period at the end of a sentence). In JAVA, you would write "var = var.substring(0, var.length()-1);". In Python, it would be "var = var[:-1] or var = var[:-1])"

In liveCode, it would be "delete the last character of var". They are able to concentrate on their algorithmns and logic not struggle with more new concepts and constructs along the way. 

With a low cognitive load language like LiveCode, you do not lose half your class after a few months. Those advanced concepts are not necessary to begin learning programming. They are overload and too much detail at the beginning levels. 

Teach them the basics, they can learn the harder aspects later. Get them productive and successful from the start. You also have more time to spend on real computer science topics such as logic, computational thinking, problem solving, and on creativity, debugging, etc. 

#3. Be Honest, Be Authentic.

Teach them to program using a real language, one that is used professionally and in the real world. Languages like Scratch, Karel and others are not used in the work world. They have too many limitations. There is a "low ceiling" to them and many things can not be programmed using them.

"In other words, just as a kid playing Guitar Hero wouldn’t be considered a musician, someone playing with coding apps isn’t exactly a coder or computer scientist.” (1)

       (1) -a quote from American Schools Are Teaching Our Kids How To Code All Wrong (...a good read)

“Today, learning scientists speak of authenticity. Learners want to learn things that are authentic, that are worthwhile. There are different senses of authenticity. Are you making things like those that professionals make? Are you using the same tools and working in the same way? Are students being assessed on concepts and skills that they need to know to be successful outside the classroom? Do students find the activities personally meaningful(see #1 above)?

Students don't have to use Java and C to be doing something honest and authentic. They should be able to make real things, to explore important ideas in computer science, and to go as deep as they want. In contrast, a "programming" tool that only allows students to move a robot or avatar is not authentic in any sense of the word. It doesn't depict a real notion of computer science.”

LiveCode is a real-world programming language that is used by corporations (NASA, etc), taught in Universities, and the language behind many top selling educational games and apps in the mobile phone stores. It is starting to become prevalent in European schools who are ahead of the US in requiring computer classes from K-12. 

It is object oriented and they learn about properties, inheritance and messages. It is text-based, line by line coding, just like Python or Java. It is no less an actual language than Java or Python. In many ways, it is more powerful, more flexible and more realistic to use than those languages. It is much easier to write real-life, "authentic" programs in.

#4. Be Productive and Creative

“Computer programs are a medium that allows us to express and communicate ideas that we can't in any other medium. Computer programming for children should be taught as a literacy that expands their ability to explore complex ideas. Children must be able to use programming to generate new ideas and be productive in learning in new domains. 

A tool in which students can build apps and games but doesn't give them programming as a tool to think with misses out on the greatest advantage of programming for learners. Programming language features which are about software development alone are likely not generative and productive, like typing "public static void main(String args[])" at the beginning of every program.

LiveCode is a GUI based and drag-n-drop programming environment making it more intuitive and relatable to the students. It is a logical extension from what they already know. 

The commands are common English words and sentences that the students use every day.  Think of it as the "pseudo-code" that we want the students to start programs with anyway.

Students are productive from day one. Within days, they can create actual programs to run on their own computers at home or give to their friends. They are quickly productive and successful. More so, than with any other language.

They can quickly advance to writing games, calculation programs, apps and much more. They can dabble with real-life issues and problems and tackle the ones that they use on their own devices. Programs that, in their wildest dreams, they never imagined that they would write. That is powerful on it's own

#5. Test, Try, Don't Trust

The hardest part about choosing a programming language for children is realizing that we can't remember what it was like to be a child and we can't actually think like children anymore. As experts, we have blind spots due to our tacit knowledge. It is literally inaccessible to our memories to think the way we did before we learned programming. When an expert says, "Oh, that's easy -- any child can do that," don't trust them. Test, try, don't trust.

Since computer science teaching is still so new, few teachers have developed a rich sense of what's hard and easy for children. We need to try things, languages, to put them into classrooms, and to measure what happens over time.

"Low threshold" means that that programming languages for learners should be easy to get started with and "high" (or no) ceiling means that the language could be used to explore a wide range of ideas. We just don't know where the threshold and ceilings are until we try. 

It's in our student's best interests that we try more experiments, keeping in mind that we need to connect with children where they are, and that we can too easily overwhelm them. 

Yet, you can still challenge them. You just have to try new ways and not trust old beliefs and methods.  It is a new and different world we now live in. We have to adapt and change to move forward.

Final Thoughts

   The New World of Computing..

"In this new world, learning coding is about moving away from computer languages, syntax, and academic exercises towards real world connections: game design and building projects that tie into other subjects like science and social studies. This is a world of software as a form of self-expression. Computer science becomes a medium for storytelling, offering exciting pathways for kids to forge a personal identity and mastery of a powerful technology. This is the inverse of how computer science has been taught, as an impersonal, disconnected, abstracted, mathematical exercise." (2)

    (2) - a quote from -  Coding Snobs Are Not Helping Our Children Prepare For The Future)      (Another good read)

We want students to learn to use programming to solve actual problems, create what they can dream up and explore what the see in the news,  They need to become creative, productive programmers with an interest in computer science and a love for programming in any language.

    Industry-Standard Languages

Sometimes we hear the idea that the only real "coder" or "computer scientist" is one that programs in a language that is used in the Tech industry. Yet we know that more than half of all programmers today are not in the Tech industry. It's tempting to teach children the languages that are freely available, ubiquitous, and commonly used by professional programmers, but those professionals tools are likely not good programming languages for learners. Fortunately, we can invent languages that are just as free, run everywhere, and are designed well for learners. Many of the languages now in demand were not in existence 10 years ago. Go, Rust, Hack, D, Swift, R. to name a few

    Starting Simple

Just like teaching reading, you do not overwhelm the students with verb tenses and punctuation. You use phonetics and simple sentences to start them reading ("See Spot run"), and add more rules and constructs as you go along. 

Students learn to drive using a car with an automatic transmission for the same reason. They need to concentrate on the road and driving a car. If you start with a standard transmission, you will overwhelm them with too much detail and cognitive load. Keep it simple and basic. Once they learn to drive, then they can learn about gears, shifting, using a clutch, etc.

With LiveCode you start them writing lines of code immediately and add more as you go along. You can even switch later to another language like Python or Java without much reteaching. Once they understand basic design, coding and debugging, they have the time, confidence and basic skills to then learn the complexities of more complicated programming languages. 

They understand basic control statements and have experience in line-by-line coding. They also have an understanding of object orientation, messaging, basic inheritance. They are easily able to transition to another language like Python, JAVA, C/C++ and others. 

    From a teacher at another school:

I second Cyril's suggestion of looking at LiveCode. It's a nice stepping-stone between drag-n-drop Scratch and text-based languages. You drag and drop user interface elements, and program them with text-based scripts. The language is very English-like and not confusing. (My favorite example is that of incrementing a variable x. Not "x++" or "x+=1" or "x=x+1" -- which offends my algebra sensibilities -- but "add 1 to x".)  The language is flexible, with more than one way to express things. ("if name = 'john' can also be expressed 'if name is 'john'", for example.)

Those of you old enough to remember HyperCard will find it to be very familiar!

When I've had students use Kahn Academy, or especially Code Academy, the exercises have seemed very picky and pedantic and have not led to creative projects. With LiveCode my kids are designing and implementing their own video games after 6-8 weeks, and have learned some significant CS concepts along the way.

The open source edition is called LiveCode Community.  You can save projects as executables for Mac, Windows, Linux, Android, and iOS. This is a programming environment that's used in real-world development; for example, some of the LandSat software is written in LiveCode. Yet it's easy enough for middle school students to use.

Department of Computer Science
The University of Chicago Laboratory Schools