Hello World

It’s tradition to begin a new “language” by creating a simple script to output the words “Hello World!”. That’s easy enough, just open your favorite text editor and enter the following:

#!/bin/bash
echo Hello World!

With only two lines, it couldn’t be a whole lot simpler, but that first line, #!/bin/bash, may not be immediately obvious. The first two characters (often called a hashbang) are a special signal. It tells Linux that this script should be run through the /bin/bash shell, as opposed to the C shell or Korn shell or anything else you might have installed. Without it, there’s no easy way for Linux to tell exactly what type of shell script this is. A Python script, for example, would likely start with something like #!/usr/bin/python.

After that is just the echo statement, which prints the words after it to the terminal (technically, to standard output).

Running Your Script

As is often the case with Linux, there are multiple ways to do this job. The most basic way would be to call bash manually and feed it the script file, as in

#Filename can be anything, .sh is a common practice for shell scripts.
bash myscript.sh

Clever readers may be thinking “But wait, didn’t we put that hashbang thing in so it would know to use bash? Why did I have to run bash manually?” and the answer is “You didn’t“. At least, you wouldn’t have if we had taken a moment to make the script executable on its own.

In the previous example, we launched bash and sent it the script. Now we’ll save ourselves some future time by making the script executable so we dont need to run bash manually. That’s as easy as a single command.

chmod +x myscript.sh

And now it can be run with the filename directly.

Variables and Arguments

Variables in bash can be a little more confusing than some other scripting languages, partly because they sometimes need to be prefaced with a $ character and sometimes not – depending on what you’re doing. Take the following example.

PATH=$PATH:/home/josh/scripts

We refer to the same variable, PATH, two times. Once there’s no $, but the other time there is. There are a few ways that you can remember when a $ is appropriate, but this author uses a “talking” metaphor. If I’m talking TO the variable (such as assigning it a new value) I call it by the short name, in this case PATH. If I’m talking ABOUT a variable (such as getting its current value) it gets a more formal title ($PATH). The precise reasoning and inner workings of this design are beyond the scope of this guide, so just try to remember that you need to include a $ if you’re trying to fetch the information in a variable.

Now we’re going to use a variable in our script. Change the second line to look like the following:

#!/bin/bash
echo Hello $1!

And re-run your script, but this time include your name after the script name.

Bash auto-assigns certain variables for you, including a few such as $1, $2 etc which hold each of the arguments passed to the script. Variables can be reassigned and renamed any way you wish, so you could rewrite the previous script as

#!/bin/bash
 
firstname=$1
lastname=$2
 
echo Hello $firstname $lastname!

As you can see, there are no $ signs when assigning the value to the variable, but you do need them when pulling the info out.

Conditionals and Loops

No script could get very far without the ability to analyse or loop through data. The most common method of determining a course of action is to use the if statement. It works much like you’d expect – IF something THEN do stuff ELSE do something different. This example compares the string of characters that we stored in the variable firstname and compares it to some hardcoded text. If they match, it prints special output. Otherwise, it continues as normal.

#!/bin/bash
 
firstname=$1
lastname=$2
 
if [ "$firstname" == "Josh" ]
then
  echo "What a great name"
else
  echo Hello $firstname $lastname!
fi

Finally, the next core component is bash’s ability to loop over data. The normal looping mechanisms for bash are FOR, WHILE, and UNTIL. We’ll start with while, as it’s the simplest.

#!/bin/bash 
         counter=0
         #While the counter is less than 10, keep looping
         while [  $counter -lt 50 ]; do
             echo $counter
             let counter=counter+1 
         done

That example creates a counter variable, begins a while loop, and continues looping (and adding one to the counter) until it reaches the limit, in this case 50. Anything after the done statement will execute once the loop is complete.

UNTIL operates similarly, but as the reverse of WHILE. A while loop will continue as long as its expression is true (counter less than 50). The until loop takes the opposite approach, and would be written as

until [  $counter -gt 50 ]; do

In this example, “while less than 50″ and “until greater than 50″ will have nearly identical results (the difference being that one will include the number 50 itself, and the other will not. Try it out for yourself to see which one, and why.)

Conclusion

As stated above, it would take a lot more than a single Getting Started article to fully demonstrate the power of bash scripting. The pieces shown here can be seen as the core components of how bash operates, and should suffice to show you the basic principles behind shell scripting in Linux. If you really want to get into the guts and start making some great scripts, check out GNU’s official bash reference guide here. Happy scripting!

Getting the Agile Platform

The Agile Platform is Windows software, and an installer can be found here. It’s worth noting that the installer may download some additional components (such as parts of IIS or SQL Server) during the install, so the process may take a while.

First Agile Application

When everything is installed, fire up Service Studio, Agile’s development environment. At the main menu, choose to start your own app from scratch. You’ll be dropped into the main editor window.

Right now you’ve just got an empty template, waiting for data. All we have to do now is give it some data (in this case, in the form of an Excel spreadsheet). Agile will create a web site based on the data.

Importing the Data

As an example exercise, we’ll create a simple bug tracker/ticket system. To make the process simpler, I’ve prepared a spreadsheet to act as the example data, which can be downloaded here.

In Service Studio, click “Import -> Entities from Excel” and choose the file you just downloaded. If you watch the right hand pane, you’ll see a few new entries show up. The section you need to worry about is Entities. In there, you’ll now see a new entity called Ticket. Drag this entity from the panel and place it directly on top of the HomePage icon.

View Your “Work”

Believe it or not, you’ve now done everything you need to do for our basic bug tracker. Have doubts? You can see for yourself by publishing the project and previewing in your browser. Click the 1-Click Publish button at the top of the screen to begin building.

It’ll take at least a few seconds, and you can watch the progress with the bar in the lower left of the screen. Once it’s done, you’ll be presented with an option to view the project in your web browser via a button in the lower right. You’ll now see the page Agile generated for you based on your data.

Pretty cool huh?

Editing Your Page and Data

You will of course want to be able to change the data once it’s in your system. Let’s start by turning the ticket number on our page into a link, which will take users to a “Edit Ticket” page. On the main flow screen, double click the silver square labeled “Ticket_List“. This will open a WYSIWYG editor where you can interactively manage the items on your page.

Right click the ticket number as demonstrated above, and select “Link to New Ticket_Edit Web Screen“. This will generate a new page where you can easily edit all the data listed. Go ahead, publish again and see for yourself.

More Information

One of the best features of this platform is that they provide an extremely comprehensive set of training materials for you to learn everything you’d need to know. It’s all available right here.

Conclusion

I’ve barely scratched the surface of Agile, and honestly, I’m already pretty blown away. It’s rare that I’m really impressed by software. As in REALLY impressed, but Agile is one heck of a product. What we’ve done in this guide is just a tiny portion of what this platform can do, but even that tiny bit shows what an amazingly well designed system this is. To me, the biggest drawback about the Agile Platform is its reliance on Windows libraries and applications. It’s not a bad thing exactly, the platform seems to work quite well on my Windows 7 test machine, but portability would have made this a real killer app. That said, I’d be willing to boot Windows once in a while if it means I can develop beautiful, functional and powerful web application in one lazy afternoon.

Quick Overview

Go is a compiled language like C or C++, not interpreted like Python. This is course means that to do anything you need a Go compiler. Since Go is only officially available in source form, that means we’ll need to compile the Go compiler with gcc. When everything is done, you will have two Go compilers available, 6g and 8g. The only difference between them is that 6g creates 64-bit binaries and 8g creates 32-bit. Once you know which compiler you want, just code and compile for Go much like you would for gcc.

There are technically other compiler options, but 6g and 8g are the official compilers and will be used exclusively in this guide.

Update: A PPA is now available for Google Go. To install, open a terminal and type:

sudo add-apt-repository ppa:gophers/go
sudo apt-get update
sudo apt-get install golang

Preparing the System

There are a few quick easy things we’ll need to do in order to get our environment prepared. First, Go requires a few environment variables to be set in the shell so that it knows where to find and place files. You could type all the following commands directly into the terminal, but since some of them may be needed later, we’ll put them all in our .bashrc file.

Open your ~/.bashrc file, and enter the following lines at the end:

#This line will tell the Go installer where to place the source code before compilation
export GOROOT=$HOME/gosource
 
#With this line, you choose the architecture of your machine.  
#Those with 64 bit CPUs should enter "amd64" here.  
export GOARCH=386
 
#Your operating system
export GOOS=linux
 
#And now the location where the installer will place the finished files
#Don't forget to create this directory before installing
export GOBIN=$HOME/gobin
 
#Include Go binaries in command path
export PATH=$PATH:$GOBIN

Then at the command line type

source ~/.bashrc

to make sure it reads the file and creates those environment variables.

Installing Build Dependencies

We need a C compiler (such as gcc) along with some other utilities to create the Go compilers (6g and 8g). At your command prompt, run the following commands to install all needed build dependencies.

#If you normally use aptitude instead of apt-get, use that here as well
sudo apt-get install bison gcc libc6-dev ed gawk make python-setuptools python-dev build-essential
sudo easy_install mercurial

Getting and Compiling the Go Source Code

Now that we’ve got everything we need to install Go, we’re ready to get the code itself. To fetch the files, enter the following command:

hg clone -r release https://go.googlecode.com/hg/ $GOROOT

Your output should approximately match the following:

And now we’re ready to compile Go into a usable language. To begin, enter the following in your terminal:

cd $GOROOT/src
./all.bash

Remember, this part is gcc compiling Go, so this will not have the speed benefits associated with writing and compiling actual Go code and will likely take a few minutes.

If you get a message about $GOBIN, make sure you remembered to create the directory that you put in your .bashrc file. Similarly, for other errors, double check the variables you put in your .bashrc file.

Test Your Installation

Save the following into a file called test.go

package main
 
import "fmt"
 
func main() {
	fmt.Printf("Hello, Go!\n")
}

Now at the command line…

#These commands are for 32-bit builds
#Replace the "8" with "6" in all examples to build for 64.  
 
#Compile...
8g test.go
#Link
8l test.8
#And run..
./8.out

If all went well, you should see something like this:

And you’re ready to start coding!

Python takes some pretty big departures from some of the more traditional languages like C/C++, fitting in better with the dynamic languages like Ruby, Smalltalk, and even Javascript. The ability to quickly and easily finish complex tasks in Python has even been the subject of some great web comics.

Note – Python is an interpreted language, the interpreter can be downloaded here. All examples in this guide are written for Python 3.0 which is NOT fully backward-compatible with prior versions. If you’re having trouble running the examples, check your Python version.

Running the examples

I’ll include various examples throughout this guide. Once you’ve got the Python 3 interpreter installed (make sure it’s Python 3), code can be run in two ways:

Script file

You can copy/paste the complete text of the example code into a text file. Python files typically end in .py. Open your command prompt and run the Python executable followed by the name of the file. On my Linux machine, I run:

python3.0 myfile.py

This should be roughly the same on Windows and Mac as well, though you may have to specify the full path to the Python interpreter, such as

C:\Python30\python.exe myfile.py

Interactive Interpreter

Python can also be run in interactive mode, where you can type in commands one at a time to see how it responds. This can be very useful in troubleshooting, or in trying out new things. Run the Python executable on its own, without any script file, and it will open up the interactive prompt.

Ctrl-D will exit the interpreter.

Whitespace

One of the most unusual aspects of Python is its use of whitespace to indicate blocks of code. Instead of begin and end, or grouping by brackets, Python uses the amount of indentation to tell how to handle blocks of code for looping and such. To many people coming from other programming languages, this seems like insanity. Once you get used to the idea, however, it becomes quite natural and forces your code to be clear and readable. We all indent code blocks anyway (or at least should) so it just makes sense for the language to understand that statements all lined up together are part of the same block.

As an added benefit, Python is not picky about just how much you like to indent, or even whether you prefer tabs or spaces. You can use a tab, a space, two spaces, 137 spaces, Python doesn’t care. All you need to do is be consistent. It will check your code and see “The first code block is indented by 4 spaces, so I’ll assume each other block is indented by another 4 spaces” or whatever the case may be. As long as you’re consistent in the way you indent your code, Python is flexible enough to understand. The following example may help clear things up.

1
2
3
4
5

x = 0
while x < 10:
    print(x)
    x += 1
print("All done")

Code Breakdown: The while loop tells Python to run the following block of code as long as certain conditions are true. In this case, the condition is that x is less than 10. It will continue to loop over that block until x hits 10. The “x += 1″ translates to “x = x + 1″ or “make x larger by 1″. Notice the final line does not get run until the while loop is finished. Python sees the indented lines, and treats those as the group of code to be run on each trip through the while loop. The final line is not indented with the others, so Python does not act on it until the while loop is finished.

Dynamic Typing

Python does not require you to define what type of data will be in a variable. You can put an integer, a string, a decimal, anything you want into a variable without having to tell Python what it is. Python will figure out, based on what you assign, what type of data that variable should hold. The following example should demonstrate:

1
2
3
4
5
6
7
8

x = 0
print("x is a: ",type(x))
x = 3.14
print("x is a: ",type(x))
x = "Hello"
print("x is a: ",type(x))
x = [1,2,3,4]
print("x is a: ",type(x))

Which gives us the output below

Data Structures

The three data structures you’ll most commonly use in python are

• Lists
• Tuples
• Dictionaries

Lists

are a lot like arrays in some other languages. They’re a one-dimensional sequence of items (though technically you can give them as many dimensions as you like). Each item in that list can be changed, moved, and removed at will without having to recreate the list, and without causing any change to the other items. Lists can contain any Python object, whether it be a number, a string, even other lists. The following code shows some basic usage of lists.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#create a list with a few sample items
myList = [1,2,3,4,5]
 
#len() gives a count of how many items our list holds
print("myList has ", len(myList), " items.")
 
#The items in a list don't have to be of the same type
myList.append("six")
myList.append("seven")
myList.append(8)
 
#We've appended three new items to the end of the list
print("myList now has",len(myList), " items.")
 
#Now let's see item number 0 (first item)
print("first item:", myList[0])
 
#and now the fourth item
print("fourth item:",mylist[3])
 
#Then pop the last item out of the list
print("and ends with" , myList.pop())
print("myList now has",len(myList), " items.")
 
#And see what we've done
print("The complete contents are:", myList)

Tuples

I won’t be covering tuples much, as they won’t be used it our example program and they’re similar to lists in many ways. Tuples, like lists, are a series of items grouped together. The difference is that tuples are not mutable. You cannot make in-place changes to the items in a tuple, you must re-create the tuple. This means no “append” or “pop” or other things that directly make changes to the contents of the tuple. If it helps, you can think of tuples as a read-only list (though that’s really not very accurate).

Dictionaries

These, I love. When I was first taught about dictionaries, I remember thinking something along the lines of “Well.. I GUESS that could be useful… sometimes”. Within a week, I used them every chance I got.

In Python, dictionaries are key:value pairs. It’s kinda like a list except that each item has two parts, a key and a value. In the following example, I’m going to make a dictionary to hold information about myself.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

myDict = {}
 
#       Key             Value
myDict["Name"]       = "Josh"
myDict["Occupation"] = "Computer Geek"
myDict["FavFood"]    = "Hani Special (no lettuce)"
myDict["FavBand"]    = "Anything but the B-52s"
myDict["Heroes"]     = "Tom Waits, Kurt Vonnegut, SpaceBat"
myDict["FavNumber"]  = 3.141592
myDict[42]           = "It's also a good number"
 
print("My name:",            myDict["Name"])
print("My heroes:",          myDict["Heroes"])
print("My favorite number:", myDict["FavNumber"])
print("What do I think of 42?", myDict[42])
print()
# Now I'll change my favorite number without creating a
# whole new dictionary
myDict["FavNumber"] += 100
print("My NEW favorite number:",myDict["FavNumber"])

A few things should be clear from the example. First, dictionaries can mix and match data of any type. Your keys and values can be of anything. You can even get really crazy and put things like functions inside dictionaries, but that’s way beyond the scope of this guide.

Second, dictionaries are mutable. You can add and remove items on the fly without recreating the dictionary or affecting other items.

If you’re still not sure of the usefulness of dictionaries, consider using them to track a user’s settings. You could have a dictionary called settings and store things like username, ip address, and screen resolution. Any time you need to reference that data, you can just pull it from settings["username"], or whatever other key you’ve specified.

Bring it all home

Now we’re going to get to the real action, creating a useful Python 3.0 program. What this program will do is take a number representing money, and tell you how much pocket change would make that amount. It’s a pretty common coding exercise and is a good way to demonstrate the concepts we’ve covered so far.

I should tell you now that this program is NOT going to be written in the “best” way, my aim is to write it using the most basic concepts and operations possible. There are several “better” ways to write this, such using functions and the modulus operator, and including error checking, but this version should be pretty easy to understand.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

#Get the cash amount
total = input("Enter cash amount in dollars:  $")
 
#Reading from text input assumes text, so convert
#to decimal and multiple by 100 so we can count pennies
#(simpler math that way)
pennies = float(total) * 100
 
#create dictionary to hold our change values
change = {"quarters" : 0,
          "dimes"    : 0,
          "nickels"  : 0,
          "pennies"  : 0}
 
#Loop until all money has been accounted for
while pennies > 0:
  #Subtract each coin from the total, add 1 to count
  #for each coin, and restart loop after counting
  if pennies >= 25:
    change["quarters"] += 1
    pennies -= 25
    continue
  elif pennies >= 10:
    change["dimes"] += 1
    pennies -= 10
    continue
  elif pennies >= 5:
    change["nickels"] += 1
    pennies -= 5
    continue
  else:
    change["pennies"] = int(pennies)
    pennies = 0
 
#Finally, print our results
print("Q:",change["quarters"])
print("D:",change["dimes"])
print("N:",change["nickels"])
print("P:",change["pennies"])

Code Breakdown: We’re using input to get an amount of money in from the command line. Python assumes that what is being entered is a string of text, as opposed to a number, so we’ve got to tell it to convert that input into a usable number. We could have left the number alone (ie 15.95) but instead we converted it to pennies (multiplying by 100) to make the maths simpler so we wouldn’t have to worry about decimal points.

Next, we create a dictionary to hold the results of our computing. If this were a more complex program, we could pass that dictionary around to our functions, classes, etc without worrying about keeping track of separate variables for each type of coin.

After that comes the real work – the act of splitting our money total into individual coins. This program uses a while loop to keep cycling until we have no money left from our original input. Each trip through the loop looks at the amount of money, subtracts the largest coin it can, and restarts the loop. Instead of doing subtractions over and over, this program would likely be much more efficient if we had used the modulus operator, but the subtraction is easier to understand.

Once we’re finished with the loop, all that’s left to do is display our results.

Python is capable of FAR more than I could possibly cover here, but I hope I’ve been able to demonstrate the basics of how it works, and how it can be used to quickly and easily create tools that would be much more complicated in a less intuitive language.

In case anyone is as curious as I was about how to properly pronounce “tuple”, I was fortunate enough to have the opportunity to ask Guido van Rossum himself if it was “toople” or “tupple”, and he gave the somewhat unsatisfying answer “It’s whatever you want.”