Introduction

The Next Scripting Language (NX) is a highly flexible, Tcl based, object oriented scripting language. It is a descendant of XOTcl, providing many additional and improved features. The scripting language NX and the Next Scripting Framework (NSF) extend the basic ideas of XOTcl by providing facilities for language-oriented programming. NSF supports multiple object systems in a single Tcl interpreter. Currently, the most prominent object systems are NX and XOTcl 2.0, but every developer is free to implement their own.

If you have experienced XOTcl in the past, you may want to take a quick look at the main differences between NX and XOTcl here. If you are happy with XOTcl, but want to take your programming skills one step further, we highly recommend our migration guide for NX. There you will learn how to use the new features introduced in NX and combine them with your existing XOTcl scripts. But don't panic: most of the existing XOTcl 1 programs can be used without modification in NSF by using XOTcl 2.0.

Prerequisites

Not much! You only need to install Tcl/Tk in version 8.5 or higher. In most Linux distributions Tcl/Tk gets shipped right away. For those of you, who haven't installed Tcl/Tk yet, just get it from www.tcl.tk. Alternatively you can do the following:

• Linux: You can install Tcl/Tk through your distribution's package manager, e.g. for Debian/Ubuntu execute sudo apt-get install tcl tcl-dev. If you are operating another Linux distribution, use your installed update or package manager accordingly.
• Mac OS X and Windows: An option is to obtain pre-combiled Tcl/Tk binaries for your operating system from, e.g. ActiveState (Linux, too). Here is a direct link to the ActiveTcl Community Edition binaries (they are free, supported by the community, and you most likely don't need more): download page.

Notice: As we are in the process of generating platform-specific binaries, you currently have to build NSF from source. Therefore, you need the Tcl development files, as well. But have no fear: if you followed the instructions above you got them already.

One last thing: In order to compile the NSF sources you need a C compiler, of course. Again, in most Linux distributions a C compiler is pre-installed (e.g., gcc). Although there are possibilities to install gcc on other platforms (check their website), you might want to try the off-the-shelf C compilers first: for Mac OS X install Apple's Xcode Developer Tools and for Windows try Microsoft's Visual C++ Express Edition (both are free).

Note: As for the source distribution of the current public beta release, our build environment has not been tested with any build environment targeting Windows (MSYS/MinGW, Visual Express). This is planned for the first stable release.

OK, now everything is set for installing NSF - are you excited already?

Download and Installation

Simply fetch the latest NSF package from our download page (or try the direct link on the left) and extract it to a directory of your choice (e.g., /usr/local/src/nsf/). After unpacking, open a shell (Linux), a terminal (Mac), or a command-line interface (MS-DOS or PowerShell on Windows) and switch to the directory you just put NSF in (e.g., cd /usr/local/src/nsf/). The next steps will show how to install NSF on a Unix-based system. If you are running another operating system, you just have to adapt slightly, but the steps remain the same.

First of all, you have to check if your system meets all requirements for compilation and configure the sources according to your computer's environment. To do that, execute the following command in the NSF directory:

If no errors show up, you can build the NSF sources by entering:

You have just compiled the NSF sources and optionally can test your compilation by executing:

In order to properly install NSF on your system (i.e., in the right place) type:

This will copy binary files to the corresponding directories and set environment paths in order to be able to execute NSF from everywhere on your system. So, you don't have to bother if you are in the right directory anymore.

Congratulations, if all of the above steps finished without errors, you have successfully installed NSF and are ready to proceed.

If you experience any problems, try to get help by exactly following the installation instructions provided in the README file. If you still are having difficulties, then do not hesitate to get in touch with the community.

Your first Steps

After successfully installing NSF, you may want to execute your first program. In order to do this, open your operating systems command-line interface (e.g., a Unix shell) again - only, if you closed it already after the installation was completed. As introduced earlier, NSF supports NX and XOTcl 2.0 as object systems. Further below, we provide the exact same examples for both (NX on the left, XOTcl 2.0 on the right). So, as a first step we want to open a Tcl shell:

Now you should be in the Tcl shell and can execute both Tcl and NX/XOTcl commands, respectively. Let's try an ordinary Tcl command:

% puts "Hello World"
#=> Hello World

Of course, you can alternatively save any command in a textfile (e.g., helloWorld.tcl) and execute it by typing:

You want to build sophisticated GUIs? Here is a 'Hello World' example by using the Tk Toolkit:

label .hello -text "Hello World"
pack .hello

In the small example, a new label widget is defined and some text is added. The second line tells the geometry manager to arrange the widget automatically. Save these two lines of code to a text file of your choice (e.g. helloWorldGUI.tcl) and execute it with the corresponding WIndowing SHell (wish), which provides a way to bring up tclsh in a graphical window as well as providing Tk support:

OK, so Tcl commands are working (also graphically). Let's move to the interesting part: We will use features provided by NX and XOTcl2.0 (namely possibilities for object-oriented programming). Therefore, we will define a minimalistic Greeter class extending the 'Hello World' example. The class will consist of two methods for saying hello and goodbye.

As shown earlier, you basically have two options for executing the script:

• Interactive mode: Open a Tcl shell (like above) and type/copy the few lines into it.
• Batch mode: Type/copy the script into a textfile and execute it like shown above (e.g., tclsh yourFileName.tcl).

package require nx

nx::Class create Greeter {
  :property name:required
  :public method "say hello" {} {
    puts "Welcome ${:name}!"
  }
  :public method "say bye" {} {
    puts "Goodbye ${:name}!"
  }
}

package require XOTcl

xotcl::Class create Greeter \
  -parameter name
Greeter instproc say_hello {} {
  my instvar name
  puts "Welcome $name!"
}
Greeter instproc say_bye {} {
  my instvar name
  puts "Goodbye $name!"
}

As you can see, the NX class owns a required property (the name of the person we would like to greet) and two methods - one for greetings, the other to say goodbye. In the case of XOTcl 2.0, we define a class with the same two methods for saying hello and goodbye. The name of the person we would like to greet is passed as a parameter at the time the class is instantiated.

Now we want to see the Greeter class in motion. Therefore, we instantiate a Greeter object and call methods on it (interactively in an open Tcl shell):

% Greeter create g -name Anna
#=> ::g
% g say hello
#=> Welcome Anna!
% g say bye
#=> Goodbye Anna!

% Greeter create g -name Anna
#=> ::g
% g say_hello
#=> Welcome Anna!
% g say_bye
#=> Goodbye Anna!

Congratulations, if you come this far, you have installed NSF correctly and even managed to run your very first code examples!

Further Information

OK, if you want to dig deeper, there are many resources you can get information from. At best you start by grapping information from the links provided in the table below.

Have fun with the Next Scripting Framework!