Calico FAQ

From IPRE Wiki

1. What is the Calico Project?

   The Calico Project is designed to create a simple but powerful programming environment for computer science education. It has two main parts: an editor, and a shell. The goal is to have a single environment for exploring different computing contexts with different computer languages.

2. What can you do with it?

   You can write programs and run them interactively. It is meant to be an all-on-one environment for easily writing and running programs on any platform. The main goal of Calico is to run the Myro robotics system.

3. What languages can one use with Calico?

   You can use Python, Ruby, Boo, Scheme, Sympl, and Dinah. Python, Ruby, Boo, and Scheme are well known programming languages. We use IronPython, IronRuby, Boo, and a new version of Scheme. Dinah is meant to be similar to the drag-and-drop language that comes with Alice. Sympl is an experimental language similar to Lisp.

4. What language is Calico written in?

   Calico is written in IronPython, and uses the Gtk graphical tool kit. It runs under Mono on MacOSX, Windows, and Linux.

5. Are there any differences between the three platforms?

   Not that we know of. Everything works identically on all three platforms.

6. Why is Calico written in Python?

   One reason is that one doesn't need to compile anything on any platform to change Calico.

7. Is the whole project written in Python?

   Everything except the modules (loadable context-based libraries, such as Graphics and Myro). The modules are written in C#, which makes them directly usable by any of the Calico languages.

8. Why use Gtk?

   We wanted to use a graphical system that ran well on all three of the major operating system platforms. We tried WinForms, but that is not as well supported on MacOSX and Linux as Gtk is.

9. Why use Mono?

   We wanted to use a framework that was as flexible as possible.

10. Why not use Java? Isn't Java important in education?

    We could have used Java, but we also did not want to force teachers and students to use a particular language. We wanted to allow flexibility in programming languages, so we are using the Dynamical Language Runtime, or DLR.

11. What is the DLR?

    The DLR is a language infrastructure written so that it would be easy to implement scripting languages. It is written to sit on the Common Language Runtime, or CLR. It was written by Microsoft, but then donated as open source software.

12. What is the CLR?

    Originally called .NET, the CLR is the heart of Microsoft's virtual machine. Mono implemented a freely available version of the CLR, which is called Mono.

13. So, the DLR sits on top of the CLR, and Mono implements the CLR via Mono?

    Yes, exactly.

14. Does Calico run directly through .NET, or does it need Mono?

    It probably could directly run under Microsoft's CLR, but it runs in Mono, and that is fine for our uses.

15. What are Calico's dependency requirements?

    Currently, you must download Mono separately. But we hope to have all of the packages in a single installer soon.

16. Is the Calico Scheme compliant with other implementations of Scheme?

    No. This is an on-going experiment to attempt to bring a Scheme language up to par with other modern scripting languages, like Python, Boo, and Ruby.

17. Is Calico Scheme a real Scheme then?

    Mostly it is. It is fully and properly tail-call optimized; there is no program call stack. It is implemented using continuations, and supports define-syntax.

18. What is Calico Scheme written in?

    It is written in Continuation Passing Style (CPS) in Scheme, and converted, through a series of transformations, into C#.

19. Can Scheme call regular CLR functions?

    Yes.

20. Can the other DLR languages call Scheme functions?

    Yes. Calico Scheme implements a method to wrap a Scheme procedure as a CLR function.

21. In what ways can the Calico languages interact?

    All of the Calico languages can share data structures and programs.

22. You mean you can write code in Ruby, Boo, Python, and Scheme, and they can all interact?

    Yes. But it depends on the language as to how well, and how much.

23. Is this slow?

    No, it is actually very fast compared to other scripting languages, especially if the other system needs to perform conversions in passing data back and forth between systems. Calico Scheme is the slowest, but we haven't yet to begin optimizing it yet.

24. How can one language load a program written in another language?

    There is the global module called "pyjama" which is available to all languages. Most languages can call pyjama.load to load in aother file, like so:

    pyjama.load("scheme-file.ss") # loading Scheme from Python

    (pyjama.load "ruby-file.rb")  ;; loading Ruby from Scheme

    pyjama.load.call "python-file.py" # loading Python from Ruby

25. What are modules written in?

    Any language that can create a .DLL can be used. For example, C# or Visual Basic.

26. Are all .DLLs usable in Calico?

    Windows can probably use any .DLL, but MacOSX and Linux can only use .DLL that are written in a cross-platform way (no P/Invokes, and no low-level C libraries, for example). However, if you write your module appropriately just using C#, then it can be run directly on all platforms.

27. What does Calico offer for educators?

    The idea is to create an environment that is productive for beginners, but scales up pedagogically as they develop more skills. Educators can also create their own language, or accessory without having to make everything necessary to deploy in the classroom.

28. Aren't there are already tools like this, such as DrScheme, or IDLE that comes with Python?

    Yes, and both of those are have inspired us and our goals. But we don't want to restrict the project to just Scheme, or just Python. We want to be able to switch, and not have to abandon all of the work on our educational environment, nor our context (3D graphics, robotics, gaming, etc).

29. What is Dinah?

    Dinah is a drag and drop language, similar to the interface that comes with Alice.

30. Why include that with these other scripting languages?

    Because we want a smooth continuum from beginner to expert. In Calico you'll be able to start with something like Alice, but then gradually move to Python (for Example). The context (say, 2D graphics) will be exactly the same.