Contents

Overview

Only relatively recently have revolutions in communication and computing technologies made possible the acquisition of information by virtually every member of an organization. As demands for both the quantity and quality of information increase, its effective management has grown from the domain of a few individuals to one of the entire business. GURU® provides an integrated solution by combining the benefits of a sophisticated expert system and relational database with common business tools such as a spreadsheet and text processor. The result is a powerful environment for developing intelligent applications for problem-solving, such as:

• Data processing applications with embedded reasoning.
• Smart applications that automatically access data and make decisions.
• Applications that consider uncertain information, explore alternatives, and recommend solutions.
• Rapid traditional application development with relational database and fourth-generation language.

This document is a general introduction to the abilities of GURU, ranging from its use in simple record-keeping to advanced applications that support complex decision-making. Here, you can read more about the many benefits GURU brings both developers and users. There are sections describing:

• The computing environments GURU supports.
• The advantages of GURU’s integrated approach.
• The sophisticated tools that make up the GURU package.
• The power and flexibility of the programming language.
• The interfaces through which GURU and its users communicate.
• Compatibility with KnowledgeMan® and previous versions of GURU.

Integrated Solutions for Information Management

GURU has a diverse user-base. From consulting, aerospace, and finance, to petrochemicals, manufacturing, and government, organizations rely on GURU to help them manage a wide range of activities including investments, production, planning, medicine, marketing, human services, legal affairs, and more. GURU is the product of choice for users in these industries because it offers outstanding knowledge processing capabilities, including:

• Unified expert system environment.
• Interactive rule set builder.
• Complete structured programming.
• Object-based programming.
• Data management.
• Standard SQL inquiry.
• Spreadsheet analysis with split-screen capability.
• Statistics generation.
• Elaborate report generation.
• Text processing.
• Screen and forms management.
• Year 2000 compliance.

Why Integration?
Of course, all of the capabilities listed above are available in stand-alone software packages. However, GURU integrates these different elements with its expert system and database so they work together in ways that no stand-alone package can.

How Integration Works
All GURU capabilities are simultaneously available, and any number of them can be used together in a single operation. This integration produces an environment of unparalleled flexibility for application development. For example:

• The premise of any expert system rule can directly reference database fields (with data imported from many sources), spreadsheet cells, statistical variables, program variables, or arrays.
• The conclusion of any expert system rule can involve database management operations, SQL queries, spreadsheet operations, statistics generation, or model execution.
• Any expert system can be consulted within a procedural model (i.e., a program) as well as interactively.
• As GURU reasons about a problem, a rule set can consult other rule sets, execute procedural programs, examine databases, do spreadsheet or statistical analyses, or interact with a user via customized forms.
• Applications can be written that update the contents of the database and spreadsheet, and even generate form letters based on information downloaded from remote systems (for example, credit checks).
• A simple application can be written that creates a table, loads data into it, interrogates the table, defines a report template, and displays or prints the interrogation results using that template.

Integration and KGL

What is KGL?
What makes this high level of integration possible is GURU’s language, KGL. KGL is the “glue” that binds together all the tools in the GURU package.

KGL is compatible with a widely-used language called SQL, or Structured Query Language. SQL has many dialects, and its function is to interrogate and process data in a relational database, either interactively or as part of a program. But KGL goes far beyond SQL, providing a rich environment of commands, built-in functions, and programming constructs that give you virtually unrestricted access to all GURU capabilities. KGL can even be used in conjunction with other languages such as C and FORTRAN.

The KGL language is a blend of two types of code, interpreted and compiled. Interpreted code is translated one line at a time into machine language. Thus, interpreted code is easy to write and debug because it can be tested one statement at a time. However, because the computer has to translate each instruction before it can act on it, interpreted code runs more slowly than compiled code.

With compiled code, the whole program is translated into machine language before it is run. Compiled code may therefore run many times faster than interpreted code. In KGL, compiled code is faster and more compact than interpreted code. Compiled code therefore has considerable advantages for any CPU-intensive operations.

GURU stores KGL source code in two types of files, .IPF and .KGL files.

.IPF Files
Interpreted Procedure Files (.IPF) are a series of GURU commands, functions, and variable assignments created with a text editor such as TEXT. The commands in the .IPF file are executed when the developer tells GURU to perform the file in which the commands are stored. For example, the following command executes the contents of the file MYFILE.IPF:

.KGL Files
.KGL files are created with a text editor just like .IPF files. However, they must be compiled before they can be run. .KGL files consist of User Defined Functions (UDFs). UDFs are essentially custom functions built from existing GURU commands and functions. When they are complied, they are written to binary files with a .KGB extension, which may be loaded and executed within GURU.

Expert System
The terms artificial intelligence and expert system are sometimes used synonymously. Artificial intelligence (AI) is a generic term which covers a very broad range of computer applications that mimic human intelligence and/or behavior. One of the major elements in any AI system is the ability to reason. This reasoning ability is central to one of the major branches of AI, expert systems.

Expert systems make it possible to capture the knowledge of a human expert in a computerized knowledge base. The knowledge base consists of data and rules for processing that data. The expert system performs analysis and reaches conclusions by running the knowledge base through an inference engine. The inference engine is the processing (or ”reasoning”) element of the expert system. A well-designed system enables users to get sound solutions to complex problems without recourse to a human expert.

GURU’s integrated expert system capabilities take information management to elevated levels, allowing for the development of a new class of intelligent applications. For example, with GURU, the following can be developed:

• Data processing applications with embedded reasoning.
• Smart applications that automatically access data and make decisions.
• Applications that consider uncertain information, explore alternatives, and recommend solutions.

Rule Sets
The core of a GURU expert system application is its rule sets. A rule set is a collection of rules which can be consulted within a GURU session to receive advice about any problem or situation within a specific domain. Rule sets are written one rule at a time, and each rule has a premise and a conclusion. Each premise in a rule can test the conditions in question by calling a built-in or UDF function, evaluating expressions, etc.

Each conclusion can include taking actions like executing a procedure file, a UDF, a CLINK module, bringing up a form, a spreadsheet, etc. KGL rule sets can be written in a text editor like other code, or a developer can use the BUILD rule set editor to get started if unfamiliar with writing rules. Once a rule set is written, the GURU COMPILE command compiles the rule set for consultation.

Fuzzy Variables and Certainty Factors
One of the most unique features of GURU is the ability to use fuzzy variables in any program or expression. Fuzzy variables are variables that have multiple simultaneous values. Each value has a certainty factor that indicates how likely it is that the variable has this value.

The ability to assign to variables multiple values of varying certainty is very important in expert system processing, because human knowledge is uncertain and different rules may conflict with one another. In a weather forecasting system, for example, one rule may indicate rainy weather, while another indicates sunny weather for the same day. Only by combining the results of a number of rules and looking at the certainty assigned to each outcome can a consensus be achieved.

GURU variables can have simple values; for example, the statement

assigns the value of 1 to the variable X. Implicitly, GURU also assigns a certainty factor; the above statement is equivalent to the statement

which assigns X a value of 1 with a certainty factor of 100. Multiple values with a single assignment could be assigned, making X a true fuzzy variable. For example, the statement

gives X three values: 1 with a certainty factor of 80, 2 with a certainly factor of 50, and 3 with a certainty factor of 30. It is important to understand that certainty factors are not a percentage of probability. In the above example, it is not correct to say that there is an 80% chance that the value of X is 1. It is only true that 1 is the most likely value of X.

When X is used with other variables and values of expression, all three values of X are used, and the result is another fuzzy variable. For example, the expression

has the value

3 with CF 80

4 with CF 50

5 with CF 30

because 2 is added to each of the possible values of X.

When combining two or more fuzzy variables in an expression, GURU calculates the possible outcomes using all the values of both expressions. For example, consider the statements

What is the value of Z? It is the combination of all the values of X and Y: 1 + 4, 1 + 5, 2 + 4, 2 + 5, 3 + 4, and 3 + 5. What are the certainty factors for the values of Z? GURU calculates these using certainty factor algebra to combine values of different certainty. GURU is unique in offering a choice of certainty factor algebras for the developer; what works best for one application may not work best for another. Using the default algebra, the value of Z in the above expression is

6 with certainty 60

5 with certainty 50

7 with certainty 50

8 with certainty 30

The value 6 is the most certain because it is the combination of the most certain values of X (1 with certainty 80) and Y (5 with certainty 60). The value 7 has a higher certainty that it otherwise would have because two combinations of values for X and Y (4 + 3 and 5 + 2) lead to a value of 7.

Database Management
GURU manages data with a relational database. A database is simply a collection of related data stored for easy access and manipulation. In a relational database, data is stored in tables, and a database may consist of a number of related tables.

Tables and Fields
A table, like a database, is a collection of related data. A table might contain all the data in a database, or it may just be a subset, one of a number of related tables. Tables consist of a name and a number of related named (or labeled) fields. For example, a table of a business’s employees might be called EMPLOYEE, and consist of fields such as LNAME, FNAME, INITIAL, SS#, STREET, CITY, ZIP, and PH#. When each field is created, its length should be specified, in addition to the kind of data to be included: numeric, integer, string (alphanumeric, or text), or logical (true or false).

A small business, for example, may have several tables of information: one containing personal data about the sales force, another data about its territories, a third its sales performance, and another a list of distributors. In GURU, a large number of these tables can be worked with simultaneously, manipulating the data in them and defining new relationships between data as you work. For example, reports can be printed that rank individuals by sales performance, or identify the most profitable territories and successful distributors.

In addition to the fields described above, another type of field, the BLOB type, can be defined.

BLOBs
BLOBs (Binary Large OBjects) are variable length fields that can store any kind of data (text or binary). Their size is limited only by the size of the hard drive. With BLOBs, text, images, and sounds, can be stored and manipulated using special KGL functions. BLOBs also store UDFs (compiled KGL code). For example, an application can be written to create a database of composers consisting of pictures, biographical data, and digitized recordings of their works. The information can then be retrieved from this database using standard SQL queries.

Indexing
Indexes for GURU tables can also be built and used for fast data retrieval. Because of GURU’s outstanding flexibility, a virtually unlimited number of indexes per table is possible. All indexing details are handled by the B+ tree technique.

Spreadsheet Analysis
The GURU spreadsheet is the electronic equivalent of the pencil, ledger sheet, and calculator used by business professionals. The spreadsheet has a broad range of sophisticated functionality, including:

• Edit both entries and the prompt line itself.
• Specify variable column widths.
• Establish cell, row, and/or column formats.
• Control borders.
• Protect cell definitions.
• Combine spreadsheets.
• Use split-screen windows.
• Control the presentation style of any cell.

In addition, GURU provides extensive read/write security for cell definitions, even down to the level of individual cells.

Because the spreadsheet is part of GURU’s seamlessly integrated environment, data can be accessed and modified from any other element of GURU, or by a GURU application.

Text Processing
With GURU’s flexible text processor, .IPF and .KGL files, as well as business documents, can be created and edited. The text editor offers full-screen editing capabilities and a full complement of general text-processing functions such as:

• Block processing
• Wildcard search and replace
• Word-wrapping
• Print formatting commands

GURU provides over 40 format controls that govern the appearance of the printed document.

Because the text processor is integrated into the GURU environment, data management, query, statistics, calculation, and other commands can be used while processing text, and the results of these commands are immediately available for integration into the document. Commands can also be executed while text is being printed, and the results are incorporated into the document as it prints.

Reports
GURU provides considerable flexibility in the generation of reports, from simple screen output of selected data in response to queries, to elaborate printouts that contain the results of complex data manipulation.

Users can design report templates interactively on the screen with the DESIGN command or the report definition language. The report definition language enables developers to design and generate reports “on the fly” within applications. Both DESIGN and the report definition language offer complete control over headers, footers, and report details.

GURU’s extensive reporting capabilities also benefit from integration. Reports can include fields, cells, statistics, and calculated expressions. GURU also supports multi-table, conditional, and sorted report generation.

Custom Applications

GURU’s powerful development environment allows for the creation of customized applications. Such applications may be “generic” (such as a general accounting package for small businesses), or they may be tailored to the needs of a specific client (an automated requisitions, purchasing, and receiving system for a container manufacturing company).

Applications developed with GURU require GURU in order to operate. In many cases, however, it is neither useful nor cost-effective to require clients to purchase a copy of the product in order to use the applications developed for them. The solution to this problem is a runtime version of GURU, which can be distributed with the application.

A runtime version of GURU gives users access to all the GURU features and commands they need to run the custom application. Because the runtime version contains only a subset of the features and commands of the full version of GURU, it is both faster and more memory efficient. However, runtime versions do not allow access to the GURU command prompt. In fact, clients need not know how to use GURU commands to run the application, or even be aware that it has been developed using GURU.

Interfaces

GURU offers a number of interfaces for users with different levels of experience with the package. Through these interfaces, developers can interact with GURU by navigating a series of menus, by typing a sequence of English language instructions, or by directly entering KGL commands. GURU also allows developers to create custom interfaces for their applications.

Command Language
The GURU KGL language provides unrestricted access to all GURU capabilities. In addition to being executed as an interpreted or compiled file, KGL commands may be entered at the GURU command prompt (Guru>). Enter commands one at a time for fast responses to queries, or to test the operation of commands to be integrated into applications. Integration makes a virtual command prompt available from within any GURU element and allows full access and interaction with all other elements.

GURU stores the last 16 commands issued. They can be cycled through using the up arrow key, edited with the cursor, insert, delete, and backspace keys, and the command can be reissued by pressing enter. Commands may also be “chained” using semicolons. For example, to copy a database table’s definition to a new table, then copy all the data contained in the first table to the new table, enter these three commands as a single chained command:

Note that command-line entries are limited to 255 characters. Although commands of such length may occupy several lines on the display, GURU treats them as single-line commands. To type entries more than 255 characters long (that is, multiple-line commands), the line continuation character (\) must be placed at or before the 255th character of the entry. Press ENTER immediately afterwards, and then the remainder of the command can be entered.

Natural Language
GURU’s natural language processing component enables a developer to communicate with GURU using normal English phrases. Application programmers can use this component to develop a natural language front end that allows users to access information, with relatively little training.

In addition to its own vocabulary of over 300 words, GURU recognizes the table and field names for all tables in use. Up to 5000 words can be added to the vocabulary manager to make GURU even more friendly.

With GURU’s word manager (WORDMAN) the current dictionary can be revised and expanded, and new definitions can be created from scratch.

Customized Interfaces
Using KGL, developers can create a custom interface for any application. The ability to create such interfaces has a number of advantages:

• Developers can create front-ends for applications that are designed specifically for the end users of those applications. The result is that users become comfortable with and learn an application quickly.
• New applications can be integrated more seamlessly into an existing environment. Designers can create interfaces that look like and behave similarly to interfaces with which the user is already familiar.
• Developers have creative control over the “look and feel” of an application.
• GURU Commander is a good example of the kind of custom interface that can be developed in KGL.

CLINK Modules
Developers who know how to program in languages such as C or FORTRAN may have existing programs, or have written new ones, which they wish to use right inside their GURU application. The CLINK component of GURU enables developers to load their compiled programs into GURU and call them directly from a .IPF or .KGL file. GURU comes with a CLINK library which offers C programmers several functions to help their code interact directly with GURU applications.

To build an external program for use in GURU, write high level code, compile it, and link it with the CLINK library file provided in the CLINK subdirectory. There is also a sample C program and compile/link file to help simplify this process. Once code is successfully compiled and linked, the LOAD FUNCTION ”cprogram” command is utilized to bring the function into GURU for use in the application. That function can be referenced like any built-in GURU function.

GURU 7.0 supports CLINK modules written in Microsoft Visual C++, or any other language that can create a 32-bit Windows Dynamic Link Library (DLL) with standard calling conventions.

International Languages
With GURU, there is no need to have separate domestic and international versions of an application. Applications are developed with the default English sorting and indexing order. Later, a language “map” file is copied on line to handle all eight bit characters and sort according to the language character set specified. .MAP files can even be customized (with the EDITMAP utility) to handle virtually any single-byte language character set.

GURU comes with .MAP files for Danish, French, Finnish, German, Norwegian, Spanish, and Swedish; one of these can be selected as the default language when the Install program is run, or can be copied later.

The EDITMAP utility is an easy-to-use graphical editor which enables customization of a .MAP file. Upper case, lower case, printer output, and sort order can be altered for any character set. Simply type editmap in the installation directory and load one of the .MAP files to get started.

GURU ODBC Driver

GURU 7.0 includes the GURU ODBC Driver, which provides read/write access to tables (.ITB data files) built for GURU. With the 32-bit GURU ODBC Driver, Windows programs that support ODBC sources, such as Crystal Reports, Microsoft Access, and Microsoft Word and Excel (through Microsoft Query), can access GURU tables and import them in reports, spreadsheets, word processing documents, and other functions. The Driver features:

Ease-of-use under Windows 95 and Windows NT.

Full support of 32-bit, Windows 95 versions of Microsoft Access and other tools.

The ability to directly link GURU data to Microsoft Access tables, allowing simultaneous access from GURU applications, with full multi-user locking.

Simple export from GURU data to native Microsoft Access tables or other formats.

Full multi-user capability for simultaneous access to data by both ODBC applications and GURU applications.

The following screen shots show the GURU ODBC Driver in action, with a graph of GURU data in Crystal Reports, followed by a report of the same data in Microsoft Access:

Figure 1. Graphics using data from GURU ODBC Driver and Crystal Reports.

Figure 2. Report using data from GURU ODBC Driver and Microsoft Access.13 GURU Technical Introduction.

Migrating from Knowledgeman and GURU

GURU 7.0 has been designed with the explicit goal of bringing the benefits of the 32-bit Windows environment in Windows 95 and Windows NT to existing KnowledgeMan and GURU applications, without requiring a rewrite of any application code.

By running as a native 32-bit application rather than in 16-bit compatibility mode, or in a “DOS box”, an application can make full use of all memory (RAM), experience greatly increased speed, and integrate completely into the Windows 95 or Windows NT environment. These benefits can be fully realized without changing a single line of code in an existing KnowledgeMan or GURU application. Simply run the application’s existing startup perform file or library under GURU 7.0. Database tables and indexes are fully compatible. The Win32 console mode allows existing user interface code to run unchanged. All KGL language elements are supported. In addition, existing context files, libraries, compiled code, and other binary application elements can in most cases be used “as is”.

Once the application is executing under GURU 7.0, users can take full advantage of the 32-bit Windows environment; for example, dimension a million-element array and experience no “out of memory” error. Further, use the GURU ODBC Driver, included with GURU 7.0, to integrate with other Windows applications, and use the GURU 7.0 CLINK facility to create 32-bit Windows Dynamic Link Libraries (DLLs) which integrate the GURU application with advanced Win32 facilities such as ActiveX. Finally, take advantage of the expert system, fuzzy logic, and other capabilities of GURU to enhance the application with advanced AI capabilities.

Access Existing KnowledgeMan and GURU Data with the GURU ODBC Driver
GURU 7.0 includes the GURU ODBC Driver, which provides read/write access to tables (.ITB data files) built for GURU and KnowledgeMan. With the 32-bit GURU ODBC Driver, Windows programs that support ODBC sources, such as Crystal Reports, Microsoft Access, and Microsoft Word and Excel (through Microsoft Query), can access GURU tables and import them in reports, spreadsheets, word processing documents, and other functions. The Driver features:

Ease-of-use under Windows 95 and Windows NT with no changes to existing KnowledgeMan or GURU applications.

Full support of 32-bit, Windows 95 versions of Microsoft Access and other tools.

The ability to directly link KnowledgeMan and GURU data to Microsoft Access tables, allowing simultaneous access from existing KnowledgeMan and GURU applications, with full multi-user locking.

Simple export from KnowledgeMan or GURU data to native Microsoft Access tables or other formats.

Full multi-user capability for simultaneous access to data by both ODBC applications and existing KnowledgeMan or GURU applications.

The screen shots on page 12 show the GURU ODBC Driver in action, with a graph of KnowledgeMan/GURU data in Crystal Reports, followed by a report of the same data in Microsoft Access.

Resolve Year 2000 Issues
The upcoming century change has a major impact on computer programs that process calendar dates, as most programs of the past 50 years have implemented calendar years as 2-digit quantities (’96, ’97, etc.) with an implied year in the 20th century (19xx). KnowledgeMan and GURU applications are no exceptions to this. While the KnowledgeMan and GURU tools have always processed dates internally as 4-digit quantities, many KnowledgeMan and GURU application programs have been implemented with 2-digit dates to save memory, database space, and processing time.

An added capability of GURU 7.0 resolves Year 2000 issues in applications built for KnowledgeMan and previous versions of GURU. Year 2000 compatibility has been designed with two goals in mind:

To provide a compatibility mechanism for applications using 2-digit years to allow these applications to run correctly on and after the Year 2000 without recoding.

To provide full 4-digit processing for applications that require it, allowing these applications to be recoded for 4- digit years.

To meet these goals, two environment variables have been added to GURU 7.0. The first environment variable, E.Y2K2, addresses the first goal by controlling the interpretation of 2-digit dates. The second variable, E.Y2K4, addresses the second goal by controlling the generation of dates with 4-digit years. Existing KnowledgeMan and GURU applications can now move confidently into the Year 2000 with minimal or no changes.

Summary of Basic Commands

KGL includes the following list of basic commands. This list is not comprehensive, but provides an overview of the command components within GURU. All of the following commands can be used in .IPF code, but only those commands marked with an asterisk (*) can presently be used in compiled .KGL code.

Expert System
BUILD
Build or edit a rule set in the multi-window rule set editor.

COMPILE
Compile a rule set for consultation.

CONSULT
Consult a rule set for general or specific.

Table Definition

DEFINE, REDEFINE, RENAME, IMPRESS, DESTROY, SHOW

Data Creation & Modification

CREATE
Creates a new record in a table.

ATTACH*
Attaches a specially formatted file (such as ASCII, DIF, BASIC, etc.) to an existing table.

CHANGE
Makes indicated changes to field values meeting specified conditions.

BROWSE
Allows you to display and modify records in a table.

MARK
Marks records for deletion (by setting #MARK=TRUE).

UNMARK
Resets the #MARK field to FALSE.

COMPRESS
Eliminates all marked records in a table.

Data Extraction
SELECT
Produces tabular output from data existing in one or more tables.

OBTAIN*
Obtains an individual record from a table, based on its (sequential) position.

PLUCK*
Gets an individual record from a table, based on an index key value.

LIST
An alias for SELECT.

Table Manipulation
SORT
Sorts a table in ascending or descending order using specified Utilities key fields.

CONVERT
Converts a table into an array, spreadsheet, or specially formatted file (such as ASCII, DIF, BASIC, SDF) for input to other software packages.16 GURU Technical Introduction.

INDEX
Builds a B+ tree index for fast record retrieval.

REINDEX
Rebuilds an existing index.

Statistics & Spreadsheet
STAT
Produces statistics for values of indicated fields that meet specified conditions.

\COMBINE
Takes two spreadsheets and combines them into one GURU spreadsheet.

CALC
Enters the interactive spreadsheet mode.

CALC DEFINE
Creates a spreadsheet without entering interactive mode.

Note: Many other spreadsheet commands are available.

Form Definition and Control
FORM
Creates a form for customized data input and/or output.

PAINT
Interactively creates and modifies FORM definitions.

GETFORM
Uses a form for data entry with automatic editing, integrity checking, and cursor movement.

PUTFORM
Displays a form, including all data output to that form, as well as titles, prompts, colors, etc.

CLEAR*
Clears the form from the screen.

RESET
Resets a form in preparation for more data entry.

TALLY
Re-evaluates the variable elements of a form.

INPUT*
Displays a prompt and accepts a data value as input.

OUTPUT*
Outputs titles, prompts, and/or data on a line.

PRINT
Prints a form and/or data at the printer device or to a file.

EJECT
Ejects a printer page.

DESIGN
Interactively creates a report template.

Report Generation
REPORT
Generates reports based on templates. Commands.

TEMPLATE
Begins a report template definition.

ENDTEMPLATE
Ends a report template definition. The last three letters (ATE) are optional.

HEADER
Defines a report, group, or page header in a template.

FOOTER
Defines a report, group, or page footer in a template.

DETAIL
Defines a detail line in a report template.

Procedural
PERFORM
Executes a pre-specified procedure. Commands.

PERFORM BREAK
Temporarily halts a procedure and returns to command line.

PERFORM CONTINUE
Resumes an application procedure after a PERFORM BREAK.

ONERROR PERFORM
Returns to an error handling procedure if #ERRNO is set (an error is detected).

ONEVENT PERFORM
Flags when an external event has occurred and initiates the corresponding procedure in GURU.

INCLUDE
An alias for PERFORM.

GLOBAL*
Specifies that a variable, form, template, etc. is accessible to all existing procedures and UDFs.

LOCAL*
Specifies that a macro, form, variable, or template is local to a procedure or UDF.

RETURN*
Returns from a procedure.

STOP
Stops all running procedures.

LET
Assigns a value to a variable.

IF-THEN-ELSE-ENDIF*
Conditional choices.

REPEAT-UNTIL*
Repeats an operation until a condition is met (UDF only).

TEST-CASE(s)

-OTHERWISE- ENDTEST*
Test for cases.

WHILE-DO-ENDWHILE*
Repetitive operations.

CONTINUE*
Immediately continues with the next iteration.

BREAK*
Breaks out of a case or repetitive operation.

WAIT*
Temporarily suspends processing until a key is pressed.

RELEASE
Releases objects from allocated memory such as forms, macros, arrays, etc.

Environment Control
SAVE
Saves current processing context.

LOAD
Loads a library or resumes a previous processing context.

BYE
Ends a session.

Language Expansion
MACRO
Define your own terms, commands, virtual tables, etc.

REDEFINE FUNCTION
Dynamically redefines the behavior of function keys.

Other Commands

HELP
Enters the on-line HELP mode.

TEXT
Full screen editor for creating and modifying procedure files and text.

System Specifications

The GURU system is designed to place very few limits on hardware capabilities. In most cases, the reverse is true: hardware places limits on GURU’s capabilities. Major design specifications for GURU are described in the following table.

Specification Item	Bounds
Rule sets	unlimited
Rules per rule set	unlimited
Rule size (characters)	unlimited
Variables per rule set	unlimited
Values per fuzzy variable	255
Built-in certainty factor algebras	16 methods
Built-in rule selection strategies	50 methods
Levels of consultation nesting	50
Tables per database	unlimited
Tables open at once	240
Records per table*	2,137,483,647
Characters per record	65,535
Fields per record	255
Characters per field	65,534
Numeric floating point representation	IEEE
Command line length (characters)	unlimited
Index keys per table	unlimited
Fields per index key	65,535
Index key length (characters)	65,535
Control break criteria per report	255
Elements per screen or report form	unlimited
Foreground colors per screen form	8
Background colors per screen form	8
Cells per spreadsheet	65,025
Windows per spreadsheet	20
Text size (lines)	32,767
Characters per text line	255
Baud rate (bits per second)**	38,400
Program length (lines)	unlimited
Working variables	unlimited
Security code combinations	65,535
Command help screens on-line	700+
Menu-guided help pages on-line	500+
Built-in vocabulary words	500+
Words per natural language word list	65,535

*The maximum records per table depends on the operating system/cpu.

**Maximum baud rate may vary depending on computer.

KGL Examples

GURU includes several excellent examples of KGL code in the form of useful applications. Much of the sample code is general in nature and written to accommodate a wide variety of operating systems and hardware. Code segments can be customized to a specific application.

The GURU Commander Menu Interface
When a GURU session begins without the -g command line option (e.g., guru16m), GURU brings up the Commander menu interface which is written entirely in KGL. The Commander interface provides many excellent examples of portable, generalized code that application developers frequently use. Much of the Commander menu interface is written in compiled KGL files with a few segments in .IPF code. This code can be examined in the GUIDE\SRC subdirectory under the home directory where GURU is installed. TEXT or another favorite editor can be used to view and edit the code. For example:

If code is borrowed from the Commander menu interface application, a copy must first be made and the original author’s name and date must be kept intact. Also, the GURU Commander menu interface source code changes in subsequent versions.

The GURU Tutorial
GURU provides an interactive tutorial to help new customers familiarize themselves with its features and strengths, including sample expert systems and rule sets. This tutorial is also written entirely in .KGL and provides many good examples of useful code. To run the tutorial or to view its source code, the working directory must be changed to the \TUTOR subdirectory as shown below.

TEXT (or any editor) can also be used to view and/or edit portions of the TUTOR source code.