Forte TOOL

TOOL was the programming language of Forte, the client/server development and deployment environment sold by Forte Software, Inc. from 1994, and later by Sun Microsystems as Forte 4GL and then the Unified Development Server (UDS). Sun’s documentation calls it Forte’s “transactional, object-oriented language”, and the name is usually expanded as Transactional Object-Oriented Language. Developers wrote an application as if it would run on one machine. Forte then partitioned it, placing the user interface on desktops and business logic and database access on servers, and handled the network traffic between the pieces. TOOL was the language those pieces were written in.

Because TOOL ran only inside the Forte environment, many users simply called their TOOL programs “Forte applications”. It is a good example of the 1990s fourth-generation, client/server languages: proprietary, tied to one vendor’s runtime, and, judging by Forte’s customer lists, used mainly for in-house business systems at large companies.

History and Origins

Forte Software was founded in February 1991. Its co-founder, president and CEO, Martin J. Sprinzen, had been Vice President of Engineering and later Executive Vice President of International Operations at Ingres Corp., the relational database company. Paul Butterworth joined as Vice President and Chief System Architect in March 1991. He had spent a decade at Ingres, as Vice President of Engineering and Chief Scientist, then worked briefly at the object database vendor Servio.

The company spent more than three years building its product. In August 1993 Butterworth, Joseph Cortopassi and Sean Fitts filed the patent application behind Forte’s central idea. It issued in October 1995 as U.S. Patent 5,457,797, “Flexible multi-platform partitioning for computer applications”: an application is built once and then distributed automatically across several networked computers, while its logic stays independent of where each part runs. The patent number still appears on the copyright page of Sun’s later TOOL manuals.

Forte Release 1.0 shipped in August 1994. The encyclopedia’s list gives 1991, the year the company was founded and work began; this page uses 1994, the year the language first reached customers.

Design Philosophy

Forte’s annual reports set out the problem it was meant to solve. First-generation client/server tools put most of the logic on each PC. To scale up, organisations then had to add server code in C or C++, database stored procedures, and transaction monitors or other middleware. Forte instead offered:

• Automatic application partitioning. You write the application as a single program. After development, Forte splits it up and places each part on a suitable machine, and you can change the partitioning later by drag and drop.
• Technology independence. Choosing the hardware, operating system and database can wait until deployment. TOOL’s database statements are neutral, and Forte translates them for the target database.
• Object-oriented development. Business entities, windows and services are all classes, which makes business logic easier to reuse.
• Interpret during development, compile for deployment. During development, TOOL source compiled to pseudo-code that ran in the Forte interpreter, so there was no long compile-and-link cycle. For deployment, Forte could instead generate C++ that was compiled by the native C++ compiler on each target machine. That choice could be made separately for each partition.

Key Features

Release 3.5 of the TOOL Reference Manual (Sun, October 2000) describes TOOL as “an object-oriented programming language, especially designed for programming in a distributed environment”. Developers used it to write methods, named event handlers, cursors and virtual attribute expressions. Classes and windows were mostly defined in Forte’s graphical workshops, though they could also be scripted with the Fscript utility.

A Taste of TOOL

The following fragments are adapted, lightly trimmed, from examples in the Release 3.5 TOOL Reference Manual. A class definition, in the form Fscript exports:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

class Artist inherits from Object
  has public
    -- Attributes
    Name    : string;
    Country : string;
    Born    : integer;
    Died    : integer;
    -- Methods
    method Init();
  has property
    shared = (allow = off);
    transactional = (allow = on, default = on);
end class;

Embedded SQL, with colons marking Forte variables:

1
2
3
4

year_born : integer = 1800;
sql select ptr_name into :name
    from painter_table
    where birth < :year_born;

Starting a task asynchronously and waiting for either its completion or a user’s Cancel click:

1
2
3
4
5
6
7
8
9

tsk : TaskDesc;
tsk = start task printer.PrintIt() where completion = event;

event case
    when printer.PrintIt_completion do
        -- ... message for success ...
    when <cancel_button>.Click do
        tsk.SetCancel();   -- cancel the printer task
end event;

Distribution and Transactions

The “transactional” in TOOL’s name refers to Forte’s own transactions, which are separate from database transactions. Everything inside a begin transaction block, including methods it calls, forms one transaction. Because an application is partitioned, the manual notes that a transaction can be distributed. A single transaction might cover work that draws a window on the client and work that queries a database on a server. Objects can be marked transactional or shared, which gives them locking and rollback behaviour. Calling a method on a reference to a remote object moves the task into the remote partition, either synchronously or asynchronously, and the network details are hidden from the programmer.

Evolution

• Release 1.0 (August 1994): the first version of the language, development environment and runtime.
• Release 2.0 (November 1995): OLE integration on Windows PCs, international applications with multi-byte character sets, Windows NT clients and servers on Intel and Digital Alpha, Power Macintosh clients, and access to ODBC, DB2/6000, Microsoft SQL Server and Informix.
• Add-on products (1996–1999): Forte Express, an application generator (March 1996); the Forte Web SDK (June 1996); Forte Conductor for workflow (September 1997); Forte WebEnterprise, the successor to the Web SDK (December 1997); and the Forte Fusion integration suite (March 1999).
• Release 3.0 (August 1997) and later 3.5, the release Sun’s October 2000 TOOL manual documents.
• Under Sun: after the merger completed on 19 October 1999, the product was sold as Forte 4GL, then as iPlanet Unified Development Server 5.0 (documentation dated August 2001) and Sun ONE Unified Development Server. UDS 5.1.3 (July 2003) replaced Forte’s own threading with native threads on Unix so that one process could use more than one processor. UDS 5.2.0 followed in September 2004, and a 5.2.4 certification matrix is dated July 2005.

Meanwhile Forte itself moved to Java. In May 1999 it announced SynerJ, a set of tools for building pure Java applications that run on standard Java virtual machines without a proprietary runtime. According to Sun’s merger proxy statement, Forte’s work with Sun on Java was part of what led to the acquisition. TOOL was not carried over to Java. It remained the language of the UDS line until that line ended.

Platforms

Forte documented different platforms in different years. Its 1996 annual report lists Windows, Windows NT, Macintosh and Motif desktops, and the following servers: Data General AViiON, Digital Alpha OpenVMS and UNIX, Digital VAX OpenVMS, HP 9000, IBM RS/6000, Sequent Symmetry, Sun SPARC and Windows NT. Supported databases included DB2/6000, Informix, Microsoft SQL Server, Oracle, Rdb and Sybase, plus ODBC. The UDS 5.2.4 certification matrix (2005) lists Tru64 UNIX, OpenVMS Alpha (server only), HP-UX, AIX, Solaris, Windows, and IBM z/OS (server only, with CICS and IMS interfaces).

Current Relevance

TOOL is a historical language. Oracle’s lifetime support policy, which covers the products Oracle inherited from Sun, lists Sun ONE Unified Development Server 5.2 as generally available from September 2004, with Premier Support ending in October 2008, no Extended Support, and indefinite Sustaining Support. No new release has appeared since the 5.2 line. TOOL cannot be run without a licensed Forte or UDS installation, and there is no open-source implementation or container image.

The documentation is still online. Oracle hosts the Forte 4GL 3.5 manuals, including the TOOL Reference Manual and Getting Started With Forte 4GL, and the UDS 5.x documentation set, including the TOOL Reference Guide, release notes and certification matrices.

Why It Matters

TOOL and Forte tried to solve a problem that became central to enterprise computing in the 1990s: how to write one business application that runs across desktops, servers, operating systems and databases from different vendors without coding the network plumbing by hand. Several of Forte’s answers resemble what later became standard practice, including location-transparent calls to remote objects, transactions that span tiers, and a managed runtime with an interpreted development mode. Others, like a proprietary language that runs only in a proprietary runtime, are exactly what the move to Java and open standards replaced, and Forte’s own switch to SynerJ shows that. Applications written in TOOL ran at banks, airlines, telephone companies and stock exchanges, and they are part of the history of large-scale client/server systems.