Difference between revisions of "CalicoDevelopment"

From IPRE Wiki
Jump to: navigation, search
(Getting Started with Development)
(From the Bottom Up)
Line 45: Line 45:
To understand all of the technology of Calico, let's start at the beginning, Hello World.
To understand all of the technology of Calico, let's start at the beginning, Hello World.
On any platform, create a file named ''HelloWorld.cs'' with the contents:
public class HelloWorld {
    public static void Main(string [] args) {
        System.Console.WriteLine("Hello, World!");
Now, we'll compile this C# code for the VM using either:
* .NET, use csc
* Mono, use mcs
= Calico2 =
= Calico2 =

Revision as of 14:39, 13 January 2012

This page describes how to work on the Calico source code. It is meant for developers who would like to understand how Calico works.

This document describes the latest version of Calico, version 2 and greater.

What is Calico?

First, let's take a step back and see Calico in the big picture. What is it exactly?

Calico is:

  1. A program written in C# that runs under Mono and .NET
  2. It has abstractions for dynamically loading two kinds of libraries:
    1. Languages
    2. Libraries

Calico is mostly GUI code, but it is really designed to be the "glue" between Languages and Libraries. Calico uses Gtk# (pronounced "gee tee kay sharp") for the graphics. Gtk is a general purpose "tool kit"... it is written in C, but has wrappers in most languages, including C++, Python, and C#. There are other graphical tool kits, but we chose Gtk because of its good support and tight connection with Mono.

.NET and Mono are Virtual Machines (VM), and a whole lot more. To try to be clear for the rest of this document, We'll use the term VM to refer to either the .NET or Mono virtual machines when it doesn't matter which.

You see the sharp sign (#) on a few libraries; this is usually a sign to indicate that the library works on the .NET VM. Not all programs written for the .NET VM will run on the Mono VM, and not all code written for the Mono VM will run on the .NET VM.

Getting Started with Development

First you'll need a VM. We'll be using the latest version, called version 4. You might need to update some items on your computer.

The only other item we'll need for building programs in general is Gtk#

  • Windows:
  • Mac:
  • Linux:

From the Bottom Up

To understand all of the technology of Calico, let's start at the beginning, Hello World.

On any platform, create a file named HelloWorld.cs with the contents:

public class HelloWorld {
    public static void Main(string [] args) {
        System.Console.WriteLine("Hello, World!");

Now, we'll compile this C# code for the VM using either:

  • .NET, use csc
  • Mono, use mcs


Getting Source Code

For those with write permissions to the SVN Bryn Mawr College source code repository, this will give you Calico2:

svn co http://svn.cs.brynmawr.edu/Calico/trunk Calico


svn co http://svn.cs.brynmawr.edu/Calico/branches/Calico1 Calico

which will give you Calico1.

Developers who have an Bryn Mawr College SVN account should use:

svn co https://svn.cs.brynmawr.edu/Calico-dev/trunk Calico


svn co https://svn.cs.brynmawr.edu/Calico-dev/branches/Calico1 Calico

You can browse the source code here:

Educational Research

You will also need:

  • mono
  • gtk (and libgtk2.0-cil-dev, for package-config files)


There are 5 directories in the Calico folder:

  1. bin - contains the startup exe and dll files
    1. bin/Lib - contains the standard Python libraries
  2. languages - contains the language definition files for Python, Ruby, Scheme, and Dinah
  3. modules - Cross-language modules that can be used by all Calico languages
  4. examples - sample code, broken down by language
  5. Source - the code to build the Calico .exe


A Language file in Calico/languages/*.py defines the editing document, and the shell executor API. Documents can do things like open, save, and display data for editing. Engines can do things like execute, execute_file, and parse files. Engines also allow for the languages to share data and functionality.


See NOTES in the Calico download (package or svn).

Screen Shots


For more, see CalicoScreenShots

Python and Ruby

Calico allows you to easily jump back and forth between languages. Enter this code in the command box:

def fib(n):
    if n <= 2: return 1
    return fib(n - 1) + fib(n - 2)

Make sure the bottom status line has Python checked, and press the Run! button (or simply hit <enter> when in the command box).

Now, enter this code in the command box (make sure to set bottom status line has Ruby checked).

class Hello_world
  def greet
    puts "Hello World"
hw = Hello_world.new

Cross-language Access

In this example, you'll see that you can access code and variables defined in other languages.

Enter the following in the Interactive Command Box:

class PythonClass:
     def hello(self, value):
         print "Python says hello to", value

This defines a PythonClass. To test it out, enter the following in the command box:

pc = PythonClass()

In the Output Box, you'll of course see:

Python says hello to Python

Now, switch to Ruby mode (bottom line status bar, select Ruby) and enter this in the command box:

pc = python_class().new
pc.hello "Ruby"

This uses the PythonClass (now called python_class). In Ruby, you can create an object by placing the .new after it. You call the method .hello by placing the arguments after the method name (parens are not needed in Ruby).

You will see in the output box:

Python says hello to Ruby

which is Python code running inside Ruby!

While in Ruby Mode, enter:

class Ruby_class
   def hello caller
     puts "Ruby says hello to #{caller}"

To see that work, try:

rc = Ruby_class.new
rc.hello "Ruby"

and you'll of course see:

Ruby says hello to Ruby

Finally, switch back to Python Mode, and enter:

import Ruby_class
rc = Ruby_class()

and you'll see:

Ruby says hello to Python

which is Ruby code running in Python!

Interacting with .NET

The languages of Calico can also interact with .NET/Mono. If you are already familiar with .NET/Mono programs (such as those written in C# or Visual Basic) then you will recognize some of these idioms and names.

As a simple example, let's use the interactive abilities to directly interact with some Windows Forms. In order to do this in Calico, will turn the threaded ability off, so as to talk to the GUI in the same thread as Calico is running in. Let's create a window (called a Form in .NET parlance):

# file: winform.py
import clr
from System.Windows.Forms import *
win = Form()

Importing the special module named clr is the gateway to interacting with the underlying .NET/Mono subsystem. From the clr module, you can add a reference to any Dynamic Link Library (DLL) so that you can access library functions and objects. In this example, we add a reference to the System.Windows.Forms DLL which contains a library of Graphical User Interface (GUI) objects. We then can create a Form, save it in a variable named win, and call the form's Show() method.

If you'd like to give the window a name, enter this in Calico's interactive command box:

win.Text = "This is the Window Title"

These windows will go away when you close Calico, or you can close them manually.

Developing a Language for the DLR in the DLR

Python and Ruby are defined to interact as above by taking advantage of the Dynamic Language Runtime (DLR). To further show this off, here is an example of defining a new language, much like Lisp, called SymPL written in Python using the tools of the DLR:

  1. lexer.py - the lexer
  2. parser.py - the parser
  3. etgen.py - expression tree generators
  4. runtime.py - runtime helpers (e.g., lookup, import)
  5. test.py - the Read Eval Print Loop

Some sample SymPL programs:

  1. test.sympl - function tests
  2. ops.sympl - operator tests
  3. lists.sympl - list tests

Writing Fast Module Code Once

Perhaps the nicest aspect of the DLR is that you can develop code (in CSharp, for example) that is "compiled" and used directly. Such can be imported and used by any language in the DLR suite as if it were written in that language. For example, consider this simple example:

// file: Testing.cs
public class Point {
  private int _x;
  private int _y;
  public Point(int x, int y) {
	_x = x;
	_y = y;
  public int x {
	get { return _x; }
	set { _x = value; }
  public int y {
	get { return _y; }
	set { _y = value; }
  public string __repr__() {
	return "<Point at (" + _x + "," + _y +")>";

This can be compiled in Mono:

gmcs Testing.cs -target:library

or put into a Project in Visual Studio, and compiled into a library.

You should then put the resulting Testing.dll somewhere will Calico can find it (either put in the same directory with the calico.exe, or put it in a directory and add the path of the directory to Python's sys.path):

import sys

Finally, you can use it in Calico:

>>> import clr
>>> clr.AddReference("Testing")
>>> import Point
>>> Point
<type 'Point'>
>>> p = Point(1,2)
>>> p
<Point at (1,2)>
>>> p.x
>>> p.x = 9
>>> p
<Point at (9,2)>

Creating Interactive Programs and Graphics for the Web

Once you have a working program in Calico, you can save the program to run on the Web in a manner very much like Flash applications. The resulting program can run in a browser using Silverlight/Moonlight. Example coming soon!


If you have any trouble, find bugs, or want to make a feature request, please do that at: