JazzScheme

• Installing from the Git sources repository

• Installing from the Git sources repository
• Getting Started
• Cataloging an existing code base
• Exploring the interface under the hood
• Executing code

• Console evaluation
• Evaluating Scheme code
• Evaluating Jazz code
• Units
• Modules
• Processes

$ git clone git://github.com/jazzscheme/jazz.git
Initialized empty Git repository in ~/jazz/.git/
got 0bf73166990a41c20627f6b935317bdc25a4e257
...
walk 1ba2fb1ad98ed81b62e2827639b71d6ec9b0ae9c
Checking out files: 100% (3284/3284), done.

$ cd jazz

$ ./jam
JazzScheme Build System v2.6

% configure
<default>
  system: gambit
  platform: windows
  safety: release
  ...

% make
...

% quit

$ bin/kernel -run c4

$ git clone git://github.com/jazzscheme/jedi.git
Initialized empty Git repository in ~/jedi/.git/
got 0bf73166990a41c20627f6b935317bdc25a4e257
...
walk 1ba2fb1ad98ed81b62e2827639b71d6ec9b0ae9c
Checking out files: 100% (3284/3284), done.

$ cd jedi

$ ./jam
JazzScheme Build System v2.6

% configure
<default>
  system: gambit
  platform: windows
  safety: release
  ...

% make
...

% quit

$ bin/jedi

• settings/Bindings.jml
• settings/Preferences.jml
• settings/Servers.jml
• settings/Workbench.jml
• _Me.jazz

• Home
• Text
• Debugger
• Groupware

• Be careful, the Console is a full fledged text. The freedom of being inside a freely editable text can be surprising to new users. Expressions to be evaluated must be entered at the end. Note that Control-Alt-Space can be while inside the console to force a fresh prompt at the end.
• The keys bound to move-upward and move-downward (alt-P and alt-N) can be used to insert previous or next expressions. Note that the previous expression does not replace the current line but is inserted instead. This enables one to type some text, use alt-P to insert a previous expression, continue typing, ...
• Another convenient way to access previous expressions, is to place the cursor on the line you want and press Enter. This will copy that line to a fresh line at the bottom.

(method (random-element seq)
  (element seq (random (length seq))))

(method (count target seq (key: key identity) (test: test eqv?))
  (let ((total 0))
    (for-each (lambda (object)
                (when (target (keyed object))
                  (increase total)))
              seq)
    total))

• Exit process
• Resume event loop

(method (count target seq (key: key identity) (test: test eqv?))
  (let ((total 0))
    (for-each (lambda (object)
                (when (test target (key object))
                  (increase! total)))
              seq)
    total))

Jazz code must exist inside a module.

Let's change the context to jazz.debuggee so we can directly access the debugging functions of that module.

> ,(in 'jazz.debuggee)
jazz.debuggee
> (inspect (list 'hello 'world))
> 

The context can also be set to a specific object. Let's set the context to the Jedi application giving us direct access to its fields.

> ,(in (get-application))
{Jedi #3}
> (list 'hello 'world 'from self (process-version))
(hello world from {Jedi #3} {Version 2 1 24 beta})
> 

Various key objects have keyword aliases, the most important one being ':profile' for your profile instance. Let's set the context to it and define a new hello-world method in our profile.

Note that for simplicity, every profile related tutorial will assume your profile name is 'Me'. If you want to be able to try out the examples as-is, login to Jedi, create a profile named 'Me' and log in using it.

> ,(in :profile)
{Me #42}
> (method (hello-world)
    (list 'hello 'world 'from self))
> (hello-world)
(hello world from {Me #42})
> 

For our first unit, we will use the existing Projects repository located at ~/.jedi/projects and the existing profile.me package located at ~/.jedi/profiles/lib/profile.me.

1- Create the unit ~/.jedi/profiles/lib/profile.me/hello/unit.scm, containing:

(unit hello.unit

(display "Hello World!"))

In the console:

> (require hello.unit)
Hello World!
> 

In this sample we will create a simple package inside the existing Projects repository. We will do it manually without using the IDE repository management tools.

1- Create the package definition file ~/.jedi/projects/lib/world/.package, containing:

(package world)

2- Create the unit ~/.jedi/projects/lib/world/hello/unit2.scm, containing:

(unit hello.unit2

(display "Hello World2!"))

3- Because Jedi's runtime has already cached packages, you can either restart the IDE or go to the "Repositories" palette, right click the "Projects" repository and select "Scan for new Packages".

In the console:

> (require hello.unit2)
Hello World2!
> 

Let's now create a new 'Tutorial' repository manually without using the IDE repository-management tools.

1- Create the repository definition file ~/tutorial/.repository, containing:

(repository Tutorial)

2- Move the previously-created world package to the new repository. E.g. move the ~/.jedi/projects/lib/world/ directory inside ~/tutorial/.

This ability to transparently move packages from one repository to another one is a key feature of the unit system.

3- Add the following entry to your ~/.jazz/.jazzini initialization file:

(jazz.install-repository-if-exists "~/tutorial/")

4- Restart the IDE

In the console:

> (require hello.unit2)
Hello World2!
> 

Let's create our first jazz module. Note that since a module is a unit, everything above applies to it too.

1- Create the module ~/tutorial/world/hello/module.jazz, containing:

(module hello.module jazz

(definition public (hello-world)
  (inspect (list hello world))))

In the console:

> (import hello.module)
Walk problems encountered
  In hello.module
    At hello-world
      Unresolved symbol: inspect
      Unresolved symbol: hello
      Unresolved symbol: world
1> 

We receive this walk-time error as modules code-walk their code and will report any unresolved symbols.

First let's clear the error level by pressing control-d in the console:

1> 
> 

And now let's fix the unresolved symbols:

(module hello.module jazz

(import (jazz.debuggee))

(definition public (hello-world)
  (inspect (list 'hello 'world))))

In the console:

> (import hello.module)
> (hello-world)
> 

We will now use the 'native' special-form to access Scheme code from a Jazz module.

Note that we are using a unit for our Scheme code solely so it is easier to load using the 'require' special-form. The code could also be in a pure Scheme file that we would then load manually using Scheme's load function.

1- Create the Scheme unit ~/tutorial/world/hello/native.scm, containing:

(unit hello.native

(define (hello-world)
  (list 'hello 'world 'from 'the 'Scheme 'world!)))

2- Create the Jazz module ~/tutorial/world/hello/access.jazz, containing:

(module hello.access jazz

(require hello.native)

(native hello-world)

(display (hello-world)))

In the console:

> (require hello.access)
(hello world from the Scheme world!)
> 

1- Create the unit that will run the product ~/tutorial/world/hello/run.jazz, containing:

(module hello.run jazz

(register-product-run 'hello
  (lambda (descriptor)
    (load-unit 'hello.access))))

2- Modify the existing world package to register the product ~/tutorial/world/.package:

(package world
  
  (products (hello (run hello.run))))

From the command line:

$ bin/kernel -run hello
(hello world from the Scheme world!)