Overview¶

Boo is an amazing language that combines the syntactic sugar of Python, the features of Ruby, and the speed and safety of C#.

Like C#, Boo is a statically-typed language, which means that types are important. This adds a degree of safety that Python and other dynamically-typed languages do not currently provide.

It fakes being a dynamically-typed language by inference. This makes it seem much like Python’s simple and programmer-friendly syntax.

int i = 0;
MyClass m = new MyClass();

i = 0
m = MyClass()

Hello, World!¶

A Hello, World! program is very simple in Boo.

Don’t worry if you don’t understand it, I’ll go through it one step at a time.

print "Hello, World!"
//    OR
print("Hello, World!")

Hello, World!
Hello, World!

Comparing code between Boo, C#, and VB.NET¶

Now you may be wondering how Boo could be as fast as C# or VB.NET.

Using their Hello World programs, I’ll show you.

print "Hello World!"

// Output: Hello World!

public class Hello
{
  public static void Main()
  {
    System.Console.WriteLine("Hello World!");
  }
}

// Output: Hello World!

VB.NET¶

Public Class Hello
  Public Shared Sub Main()
    System.Console.WriteLine("Hello World!")
  End Sub
End Class

' Output: Hello World!

All three have the same end result and all three are run in the .NET Framework.

All three are first translated into MSIL, then into executable files.

MSIL Diagram

If you were to take the executables created by their compilers, and disassemble them with ildasm.exe, you would see a very similar end result, which means that the executables themselves are very similar, so the speed between C# and Boo is practically the same, it just takes less time to write the Boo code.

Booish¶

booish is a command line utility that provides a realtime environment to code boo in. It is great for testing purposes, and I recommend following along for the next few pages by trying out a few things in booish. You can invoke it by loading up a terminal, then typing booish (this assumes that Boo is installed and in your system path), or by double-clicking the booish icon. In booish, you can up arrow to re-enter (with editing) a previously entered line. Here’s what booish will look like:

>>> print "Hello, World!"
Hello, World!

Exercises¶

1. Write a Boo program that prints Hello, World!, then prints Goodbye, World!
2. Play around with booish
3. Advanced: Compile the Hello, World! programs for Boo (using booc) and C# (using csc or mcs), run ildasm on each of them and compare the result.

Using Booish as a Calculator¶

There are four basic mathematical operators: addition +, subtraction -, multiplication *, and division /. There are more than just these, but that’s what will be covered now.

>>> 2 + 4 // This is a comment
6
>>> 2 * 4 # So is this also a comment
8
>>> 4 / 2 /* This is also a comment */
2
>>> (500/10)*2
100
>>> 7 / 3 // Integer division
2
>>> 7 % 3 // Take the remainder
1
>>> -7 / 3
-2

You may have noticed that there are 3 types of comments available, //, #, and /* */. These do not cause any affect whatsoever, but help you when writing your code.

You may have noticed that 7 / 3 did not give 2.333…, this is because you were dividing two integers together.

The way computers handle integer division is by rounding to the floor afterwards.

In order to have decimal places, you must use a floating-point number.

>>> 7.0 / 3.0  # Floating point division
2.33333333333333
>>> -8.0 / 5.0
-1.6

If you give a number with a decimal place, even if it’s .0, it become a floating-point number.

Types of Numbers¶

There are 3 kinds of floating point numbers, single, double, and decimal.

The differences between single and double is the size they take up. double is prefered in most situations.

These two also are based on the number 2, which can cause some problems when working with our base-10 number system.

Ususally this is not the case, but in delecate situations like banking, it would not be wise to lose a cent or two on a multi-trillion dollar contract.

Thus decimal was created. It is a base-10 number, which means that we wouldn’t lose that precious penny.

In normal situations, double is perfectly fine. For a higher precision, a decimal should be used. Integers, which we covered earlier, have many more types to them.

They also have the possibility to be “unsigned”, which means that they must be non-negative.

The size goes in order as such: byte, short, int, and long.

In most cases, you will be using int, which is the default.

Characters and Strings¶

All the letters in the alphabet are characters. All the numbers are characters. All the symbols of the Mandarin language are characters. All the mathematical symbols are characters.

In Boo/.NET, characters are internally encoded as UTF-16, or Unicode.

The word “apple” can be represented by a string.

>>> s = "apple"
'apple'
>>> print s
apple
>>> s += " banana"
'apple banana'
>>> print s
apple banana
>>> c = char('C')
C
>>> print c
C

Now you probably won’t be using chars much, it is more likely you will be using strings.

To declare a string, you have one of three ways.

1. using double quotes. “apple”
2. using single quotes. ‘apple’
3. using tripled double quotes. “”“apple”“”

The first two can span only one line, but the tribbled double quotes can span multiple lines.

The first two also can have backslash-escaping. The third takes everything literally.

>>> print "apple\nbanana"
apple
banana
>>> print 'good\ttimes'
good      times
>>> print """Leeroy\Jenkins"""
Leeroy\Jenkins

Common escapes are: * {{ … }} literal backslash * newline * carriage return * tab

If you are declaring a double-quoted string, and you want a double quote inside it, also use a backslash.

Same goes for the single-quoted string.

>>> print "The man said \"Hello\""
The man said "Hello"
>>> print 'I\'m happy'
I'm happy

strings are immutable, which means that the characters inside them can never change. You would have to recreate the string to change a character.

String Interpolation¶

String interpolation allows you to insert the value of almost any valid boo expression inside a string by preceeding a lonesome variable name with $, or quoting an expression with $().

>>> name = "Santa Claus"
Santa Claus
>>> print "Hello, $name!"
Hello, Santa Claus!
>>> print "2 + 2 = $(2 + 2)"
2 + 2 = 4

String Interpolation is the preferred way of adding strings together. It is preferred over simple string addition.

String Interpolation can function in double-quoted strings, including tripled double-quoted string.

It does not work in single-quoted strings.

To stop String Interpolation from happening, just escape the dollar sign: ${}

Booleans¶

Boolean values can only be true or false, which is very handy for conditional statements, covered in the next section.

>>> b = true
true
>>> print b
True
>>> b = false
false
>>> print b
False

Object Type¶

Everything in Boo/.NET is an object.

Although some are value types, like numbers and characters, these are still objects.

>>> o as object
>>> o = 'string'
'string'
>>> print o
string
>>> o = 42
42
>>> print o
42

The problem with objects is that you can’t implicitly expect a string or an int.

If I were to do that same sequence without declaring o as object,

>>> o = 'string'
'string'
>>> print o
string
>>> o = 42
--------^
ERROR: Cannot convert 'System.Int32' to 'System.String'.

This static typing keeps the code safe and reliable.

Declaring a Type¶

In the last section, you issued the statement o as object.

This can work with any type and goes with the syntax <variable> as <type>.

<type> can be anything from an int to a string to a date to a bool to something which you defined yourself, but those will be discussed later. In most cases, Boo will be smart and implicitly figure out what you wanted.

The code i = 25 is the same thing as i as int = 25, just easier on your wrists.

List of Value Types¶

Exercises¶

1. Declare some variables. Go wild.

If Statement¶

An if statemnt allows you to travel down multiple logical paths, depending on a condition given. If the condition given is true, the block of code associated with it will be run.

i = 5
if i == 5:
    print "i is equal to 5."

// Output: i is equal to 5.

i = 5
if i > 0:
    print "i is greater than 0."
    if i < 10:
        print "i is less than 10."
        if i > 5:
            print "i is greater than 5."

// Output: i is greater than 0.
//         i is less than 10.

If-Else Statement¶

With the if statement comes the else statement. It is called when your if statement’s condition is false.

i = 5
if i > 5:
    print "i is greater than 5."
else:
    print "i is less than or equal to 5."

// Output: i is less than or equal to 5.

If-Elif-Else Statement¶

Now if you want to check for a condition after your if is false, that is easy as well. This is done through the elif statement.

i = 5
if i > 5:
    print "i is greater than 5."
elif i == 5:
    print "i is equal to 5."
elif i < 5:
    print "i is less than 5."

// Output: i is equal to 5.

Unless Statement¶

The unless statement is handy if you want a readable way of checking if a condition is not true.

i = 5
unless i == 5:
    print "i is not equal to 5."

// Output:

Statement with Modifier¶

Like in Ruby and Perl, you can follow a statement with a modifier.

```boo i = 0 print i i = 5 if true print i i = 10 unless true print i

// Output: 0 // 5 // 5 ```

Some common conditionals:

Not Condition¶

To check if a condition is not true, you would use not.

i = 0
if not i > 5:
    print "i is not greater than 5"

// Output: i is not greater than 5

Combining Conditions¶

To check more than one condition, you would use and or or. Use parentheses ( ) to change the order of operations.

i = 5
if i > 0 and i < 10:
    print "i is between 0 and 10."
if i < 3 or i > 7:
    print "i is not between 3 and 7."
if (i > 0 and i < 3) or (i > 7 and i < 10):
    print "i is either between 0 and 3 or between 7 and 10."

// Output: i is between 0 and 10.

Note that and requires that both comparisons are true, while or requires that only one is true or both are true.

Exercises¶

1. Given the numbers x = 4, y = 8, and z = 6, compare them and print the middle one.

For Loop¶

A for loop in Boo is not like the for loop in languages like C and C#. It is more similar to a foreach.

The most common usage for a for loop is in conjunction with the range function.

The range function creates an enumerator which yields numbers.

The join function in this case, will create a string from an enumerator.

join(range(5))         // Output: 0 1 2 3 4
join(range(3, 7))      // Output: 3 4 5 6
join(range(0, 10, 2))  // Output: 0 2 4 6 8

for i in range(5):
    print i

// Output: 0
//         1
//         2
//         3
//         4

While Loop¶

The while loop is very similar to an if statement, except that it will repeat itself as long as its condition is true.

i = 0
while i < 5:
    print i
    i += 1

// Output: 0
//         1
//         2
//         3
//         4

Continue Keyword¶

The continue keyword is used when looping. It will cause the position of the code to return to the start of the loop (as long as the condition still holds).

for i in range(10):
    continue if i % 2 == 0
    print i

// Output: 1
//         3
//         5
//         7
//         9

While-Break-Unless Loop¶

the while-break-unless loop is very similar to other languages do-while statement.

i = 10
while true:
    print i
    i -= 1
    break unless i < 10 and i > 5

// Output: 10
//         9
//         8
//         7
//         6
//         5

Pass Keyword¶

The pass keyword is useful if you don’t want to accomplish anything when defining a code block.

while true:
    pass //Wait for keyboard interrupt (ctrl-C) to close program.

Exercises¶

1. print out all the numbers from 10 to 1.
2. print out all the squares from 1 to 100.

Lists¶

Lists are mutable, which means that the List can be changed, as well as its children.

print([0, 'alpha', 4.5, char('d')])
print List('abcdefghij')
l = List(range(5))
print l
l[2] = 5
print l
l[3] = 'banana'
print l
l.Add(100.1)
print l
l.Remove(1)
print l
for item in l:
    print item

// Output:
// [0, alpha, 4.5, d]
// [a, b, c, d, e, f, g, h, i, j]
// [0, 1, 2, 3, 4]
// [0, 1, 5, 3, 4]
// [0, 1, 5, 'banana', 4]
// [0, 1, 5, 'banana', 4, 100.1]
// [0, 5, 'banana', 4, 100.1]
// 0
// 5
// 'banana'
// 4
// 100.1

Slicing¶

Slicing is quite simple, and can be done to strings, Lists, and arrays.

It goes in the form var[start:end]. both start and end are optional, and must be integers, even negative integers.

To just get one child, use the form var[position]. It will return a char for a string, an object for a List, or the specified type for an array.

Slicing counts up from the number 0, so 0 would be the 1st value, 1 would be the 2nd, and so on.

list = List(range(10))
print list
print list[:5]    // first 5
print list[2:5]   // starting with 2nd, go up to but not including the 5
print list[5:]    // everything past the 5th
print list[:-2]   // everything up to the 2nd to last
print list[-4:-2] // starting with the 4th to last, go up to 2nd to last
print list[5]     // the 6th
print list[-8]    // the 8th from last
print '---'
str = 'abcdefghij'
print str
print str[:5]     // first 5
print str[2:5]    // starting with 3rd, go up to but not including the 6th
print str[5:]     // everything past the 6th
print str[:-2]    // everything before the 2nd to last
print str[-4:-2]  // starting with the 4th to last, to before the 2nd to last
print str[5]      // the 6th
print str[-8]     // the 8th from last

// Output
// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
// [0, 1, 2, 3, 4]
// [2, 3, 4]
// [5, 6, 7, 8, 9]
// [0, 1, 2, 3, 4, 5, 6, 7]
// [6, 7]
// 5
// 2
// ---
// abcdefghij
// abcde
// cde
// fghij
// abcdefgh
// gh
// f
// c

Arrays¶

Arrays, unlike Lists, cannot change their size. They can still be sliced, just not added on to. Arrays can be defined three ways: 1. by using parentheses () 1. If you have 0 members, it’s declared: (,) 2. If you have 1 member, it’s declared: (member,) 3. If you have 2 or more members, it’s declared: (one, two) 2. by creating a new array wrapping an IEnumerator, or an List. 3. by creating a blank array with a specified size: array(type, size)

print((0, 'alpha', 4.5, char('d')))
print array('abcdefghij')
l = array(range(5))
print l
l[2] = 5
print l
l[3] = 'banana'

// Output
// (0, alpha, 4.5, d)
// (a, b, c, d, e, f, g, h, i, j)
// (0, 1, 2, 3, 4)
// (0, 1, 5, 3, 4)
// ERROR: Cannot convert 'System.String' to 'System.Int32'.

List to Array Conversion¶

If you create a List of ints and want to turn it into an array, you have to explicitly state that the List contains ints.

list = []
for i in range(5):
    list.Add(i)
    print list
a = array(int, list)
for a_s in a:
    print a_s
a[2] += 5
print a
list[2] += 5
print list[2]

// Output
// [0]
// [0, 1]
// [0, 1, 2]
// [0, 1, 2, 3]
// [0, 1, 2, 3, 4]
// (0, 1, 2, 3, 4)
// (0, 1, 7, 3, 4)
// ERROR: Operator '+' cannot be used with a left-hand side of type 'System.Object' and a right-hand side of type 'System.Int32'

Casting¶

To get around a list storing only objects, you can cast an object individually to what its type really is, then play with it like it should be.

Granted, if you cast to something that is improper, say a string to an int, Boo will emit an error. There are two ways to cast an object as another data type. 1. using var as <type> 2. using var cast <type>

list = List(range(5))
print list
for item in list:
    print ((item cast int) * 5)
print '---'
for item as int in list:
    print item * item

// Output
// [0, 1, 2, 3, 4]
// 0
// 5
// 10
// 15
// 20
// ---
// 0
// 1
// 4
// 9
// 16

Hashes¶

Hashes are also called “dictionaries” in some other languages. Hashes are very similar to Lists, except that the key in which to set values can be an object, though usually an int or a string. Hashes can be defined two common ways: 1. by using braces {} 2. by creating a new Hash wrapping an IEnumerator, or an IDictionary.

hash = {'a': 1, 'b': 2, 'monkey': 3, 42: 'the answer'}
print hash['a']
print hash[42]
print '---'
for item in hash:
    print item.Key, '=>', item.Value

# the same hash can be created from a list like this :
ll = [ ('a',1), ('b',2), ('monkey',3), (42, "the answer") ]
hash = Hash(ll)

// Output
// 1
// the answer
// ---
// a => 1
// b => 2
// monkey => 3
// 42 => the answer

Exercises¶

1. Produce a List containing the fibonacci sequence that has 1000 values in it. (See if you can do it in 4 lines)