Office of Digital Humanities
By the end of this reading you should be able to answer the following questions, within the context of LiveCode:
Where did this term come from?
George Boole, 1815–1864, was an English mathematician who invented a system of logical algebra, known today as Boolean logic. He is considered the father of the field of computer science.
A Boolean value is simply a value of either true or false. Sometimes Boolean values are referred to as binary values, because they can only have one of two values—e.g., on or off, 0 or 1, true or false. In LiveCode Boolean values are expressed by the constants true and false. You create a Boolean variable simply by putting a Boolean value into it:
put true into answerIsCorrect
In LiveCode, as in any programming language, it is frequently necessary to compare values; that is to discover whether two values or expressions are equivalent, whether one is greater than the other, and so on. For that we have a set of tools called relational operators. Comparing two values using relational operators results in a Boolean expression, because the relationship can only be evaluated to true or false. LiveCode recognizes the standard algebraic comparison symbols as relational operators:
= | 'is equal to' |
<> | 'is not equal to' |
< | 'is less than' |
> | 'is greater than' |
<= | 'is less than or equal to' |
>= | 'is greater than or equal to' |
LiveCode also recognizes these keywords as relational operators:
is | same as '=' |
is not | same as '<>' |
The word Boolean is also used to describe any expression that results in either a true or false condition. You will use Boolean expressions constantly in LiveCode programming. They are the basis for making decisions in an if-then structure, for instance.
Here are some examples of Boolean expressions:
the date = "10/13/12"
myName is "John" --(i.e., is the contents of the variable exactly the same as the contents of the literal?)
field "score" > 80
myScore <> yourScore
Comparing Strings:The comparison of words or strings of letters is based on alphabetical order. Consequently, a word that comes before in alphabetical order is considered less than a word that comes after:
Complex Boolean Expressions: The logical operators and, or, and not can be used to build complex logical expressions. Use parentheses to nest or group expressions as necessary. For example:
x = 20 and y < 45 or z >= 90
In this example, because the statement is processed from left to right, the entire statement would resolve to true if the first two expressions were both true or if the third expression were true. If the third expression were false and one of the first two were false, then the whole statement above would resolve to false. Now consider this statement:
x = 20 and (y < 45 or z >= 90)
Since the parentheses force the second group of Boolean expressions to be evaluated first, the entire statement would only be true if the first expression were true and at least one of the other expressions were true.
An if-statement is a conditional control structure that allows for checking a certain condition before taking an action. Boolean operators are an essential ingredient in these types of statements. LiveCode has several forms of the if-statement.
The most basic form of the if statement has a beginning, a middle, and an ending, much like a handler:
if condition then statement end if
where
condition is an expression that resolves to true or false.
statement is any valid LiveCode command or statement.
In a handler an if-then statement would look something like this:
on mouseUp
put field "answer 1" into x
if x = 3 then
put "Your answer is correct!" into field "response"
end if
end mouseUp
This handler takes the content of a field and puts it into a variable. It then checks to see if the variable's content is equal to 3. If this is true, then an appropriate response is put into another field. If the variable does not contain 3, then the statement is false and the LiveCode statement within the if...end if structure is not executed.
Often you will want to perform one action if a condition is true and another action is it is false. For this you use the if-then-else form, which simply adds another clause, or section, to the structure:
if condition then statement else statement end if
where
condition is an expression that resolves to true or false.
statement is any valid LiveCode command or statement.
Here is an example of an if-then-else structure in a handler:
on mouseUp
put field "answer 1" into x
if x = 3 then
put "Your answer is correct!" into field "response"
else
put "Your answer is incorrect! Try again." into field "response"
end if
end mouseUp
Expanding the example used above, the else portion of this statement provides for everything else the variable may contain besides 3. Consequently, for everything but 3 it will indicate that the response is incorrect.
Even though it may seem like extra typing, beginning programmers should get into the habit of using this "complete" form, because it keeps the statement very clean and unambiguous. As you will see later, there are other forms that LiveCode allows. For now, however, just stick to the basic format shown here.
The first two examples of the if-statement only showed one statement in each clause. However, you may include as many statements as you need in both the if and the else clauses:
if condition then statement statement ... else statement statement ... end if
where
condition is an expression that resolves to true or false.statement is any single LiveCode statement.
In a handler, this form of the if/then/else-statement would look something like this:
on mouseUp
put field "answer 1" into x
if x = 3 then
show image "smileyFace"
put "Your answer is correct!" into field "response"
wait 2 seconds
hide image "smileyFace"
put empty into field "response"
else
beep
put "Your answer is incorrect! Try again." into field "response"
wait 2 seconds
put empty into field "response"
end if
end mouseUp
Building upon the example used previously, this handler now does more depending upon the contents of the variable x. If x contains 3 then an image is shown and text is put into a field. The computer waits a few seconds, then hides the image and erases the text. If x contains anything other than 3, then the computer plays the alert sound and gives an appropriate textual response, erasing the text after a few seconds.
The results of a conditional statement or logical expression can be placed into a variable. This consequently makes the variable contain either true or false (hence, becoming a Boolean), enabling the variable to be checked much like a conditional statement. This is desirable in many cases where you would want to confirm a certain condition as being met without evaluating a conditional statement each time. All that needs to be done would then be to check if the variable itself contained either true or false.
To see this in action, imagine that you have some type of exam that contains a listening component. The instructor wishes the students to begin with the listening section before being able to view the pertinent questions. Once they leave the card that gives them access to the sounds, they should not be able to return to listen to it again. This could be accomplished in this manner:
on mouseUp
global heardSound
if heardSound then
beep
put "You've already listened to the sounds." into field "response"
wait 2 seconds
put empty into field "response"
go card "Questions 1-12"
else
go card "Listening Comprehension"
end if
end mouseUp
Previously when the stack was opened, the global variable had been given a value with a statement like this: put false into heardSound (this variable would then change depending upon the actions of the user). This handler then accesses the global variable and checks its value. Note how this is done (as opposed to if heardSound = true). Appropriate action then takes place depending upon the value within the variable. As stated before, it is often more appropriate (and legible) to use a Boolean variable in this manner rather than employing a conditional statement.
Again, the if-statement is a powerful tool for getting the stack to execute functions on a conditional basis, i.e., when certain conditions are met.
LiveCode tries to provide more flexibility to the programmer as compared to some other languages. Accordingly, there are "simpler", single line forms for the if/then statement. However, these forms can often become confusing, especially when embedding if-then structures within other if-then structures. For the beginning programmer we recommend sticking to the "complete" format shown above, at least until you become very familiar with how if-then structures work. Because you may encounter these single-line forms, they are included for your information.
This form of the if-statement may only be used to execute a single command when a condition is true. Its syntax is:
if condition then statement
where
condition is an expression that resolves to true or false.statement is any single LiveCode statement.
Practically speaking, the single-line if-then statement would look something like this within a handler:
on mouseUp put field "answer 1" into x if x = 3 then put "Your answer is correct!" into field "response" end mouseUp
if condition then statement
else statement
where
condition is an expression that resolves to true or false.statement is any single LiveCode statement.
In a handler, the single-line if/then/else-statement would look something like this:
on mouseUp put field "answer 1" into x if x = 3 then put "Your answer is correct!" into field "response" else put "Your answer is incorrect! Try again." into field "response" end mouseUp
The if–then–else structure is very good for setting up either-or, true-false decisions in your code. The if ... then line of the structure determines what happens if the condition is true, and the else section determines what happens if the condition is not true.
But what if there are more than two possible values to check? What if, instead of evaluating a true-false condition you want to evaluate, for example, a range of numeric values. Imagine you are creating a quiz with 10 questions. Students who get more than 8 correct are considered in the top tier, students who get 6 to 8 correct are in the middle tier, and those with 5 or lower are in the bottom tier. How can handle this with an if–then–else structure?
LiveCode, like many programming languages, allows you to extend an if-then structure by adding additional else clauses. The code for the example above might look something like this:
global numberCorrect
on checkAnswer
if numberCorrect >= 8 then
put "Fabulous!" into fld "feedback"
else if numberCorrect > 5 then
put "Not bad." into fld "feedback"
else
put "Time to hit the books!" into fld "feedback"
end if
end checkAnswer
In theory the multiple else if clauses can be extended indefinitely to handle many different conditions. However, there is another conditional structure that is better suited for decision structures with many potential outcomes. It is called a switch structure.
The basic format for a switch structure looks like this:
switch expression or variable
case value1
-- do something
break
case value2
-- do something else
break
case value3
-- do something different
break
default
-- what to do if no match found
end switch
The expression or variable determines the source of the values that are matched in the case clauses. The break statement means “once a value is matched stop here and exit the switch structure.” The optional default section is what executed if no case clauses are matched.
Let’s say we’re building a calendar stack that gives you helpful messages depending on which day of the week it is. You can easily discover which day is it like this:
put item 1 of the long date into dayOfWeek
Now we can build a switch statement based on the day of the week, like this:
switch dayOfWeek
case "Monday"
beep
put "Oh, no! Back to work!" into fld "mood"
break
case "Friday"
put "Finally! Time to play!" into fld "mood"
break
case "Saturday"
put "Chores today!" into fld "mood"
break
case "Sunday"
put "My day of rest." into fld "mood"
break
default
put "Humdrum work day." into fld "mood"
end switch
The switch structure provides a neater look for multiple-value conditional structure than if–then–else structures. It also provides efficiencies under the hood that make it better suited for multiple-value conditional structures.
See the entry for switch in the LiveCode Dictionary for more on how to use this powerful and useful control structure.
The repeat statement in LiveCode lets you set up looping structures, which allow a series of commands to be repeated under various conditions. Used properly, a repeat loop allows for more efficient coding, since you can reuse multiple lines of code over and over.
The general form of the Repeat statement consists of the key word repeat at the beginning and a matching end repeat at the end, with any number of LiveCode statements between.
repeat loop form statement ... end repeat
where
loop form is an expression that determines the type of loop structure, including the conditions for terminating the loop.
statement is any single LiveCode statement.
There are four basic variations of the loop form:
This specifies a fixed number of times the enclosed statements are to be repeated. A simple example would be:
on mouseUp
repeat for 4 times
show image "Wow!"
wait 10
hide image "Wow!"
wait 10
end repeat
end mouseUp
Within this handler, this repeat structure would show and hide the image specified (with pauses between each) four times, creating a blinking image. The repeat structure will execute its statements exactly the number of times specified.
This repeats with a counter variable that can be accessed within the loop. The repeat with statement specifies a variable to use, a start value and an end value. When processing enters the loop the variable is assigned the start value, then is incremented by 1 each time the loop repeats. When it reaches the end value, looping ends. For example:
on mouseUp
repeat with count = 1 to 10
put count into field "timer"
wait 1 second
end repeat
beep
end mouseUp
This handler utilizes the nature of the repeat loop form to change the content of a field. The repeat control structure creates a variable called "count" and initializes it to 1. The first time through the loop it puts the contents of the variable (the value 1) into a field and waits one second. The repeat structure then increments the contents of count by 1. This value (now 2) is then displayed in the field, and so on up until count contains 10, which is the last value displayed in the field. The repeat loop then finishes and the computer plays an alert sound. This particular handler creates a type of ten-second timer that displays the amount of time passed and alerts when ten seconds have passed.
These are logically reciprocal forms. The English meaning best conveys it: The repeat while statement repeats the commands inside the loop while a condition is (or remains) true, and repeat until statement repeats commands until a condition becomes true. For example:
on mouseUp
put 1 into count
repeat while count <= 10
put count into field "timer"
wait 1 second
add 1 to count
end repeat
beep
end mouseUp
This handler accomplishes the same end as the example given above. However, in this case it is necessary to manually initialize the variable count outside the loop and manually increment it inside the loop for it to function as we would like.
Note: If "<" were used instead of "<=" within the loop form, then the loop would execute only 9 times instead of 10.
Here is an example of the repeat until-statement:
on mouseUp
put 1 into count
repeat until count > 10
put count into field "timer"
wait 1 second
add 1 to count
end repeat
beep
end mouseUp
Again, this accomplishes the same end as the previous examples. It is still necessary to manually initialize and increment the variable.
Note: If ">=" were used instead of ">" within the loop form, then the loop would execute only 9 times instead of 10.
This is similar to the repeat with structure, except that instead of incrementing a variable, this repeat structure allows one to step through the various elements—characters, words, lines, etc.—within a container. (We will discuss these elements, also called chunks, in more detail in a later lesson.) This structure is useful if you need to manipulate or perform an action on each element within a container, as it is much faster and easier to work with than the repeat with structure. For example:
on mouseUp
repeat for each word thisOne in field "fullText"
put thisOne & return after field "wordList"
end repeat
end mouseUp
This handler steps through the text of the field, one word at a time, and then places each word on a separate line in another field. This type of repeat loop is very useful in cases where you need to examine chunks of text one at a time.