Amzi! Prolog
+
Logic Server

Download

White Papers

Videos

Articles

Documentation

User Stories

User Software

Amzi! Prolog + Logic Server ™

Amzi! Prolog + Logic Server makes it easy to integrate rule-based components with Windows, Linux, Sun Solaris, HP/UX and other applications (see list below).
 

Amzi! offers plug-in, rule-based services for C, C++, Java, Web Servers (via ASP.NET, JSP, Java Servlets, CGI), Delphi, VB.NET, C#.NET, PowerBuilder, Access, Excel and many other tools.

The integration is achieved through the Logic Server API which lets you access a logic-base of rules as easily as you access a database today. The result is a manageable and well-behaved interface that makes it possible to utilize rule-based programming everywhere it is needed (see diagram).

"I've been looking for a Prolog with this kind of API for years ... it is designed to work equally well both ways (embed-dable AND extendable), ... it is small yet seems very complete."  Jonas Beckman, MU Data

State-of-the-Art Interactive Development Environment

The Amzi! Eclipse IDE features:

• Syntax coloring in the editor to highlight built-in predicates, strings, comments, etc.
• Source file outliner and project cross referencer.
• Source code bookmarks to indicate the locations of errors, to-do items, search text and more.
• Full source code debugging showing variable bindings at each level in the call stack.
• Full source code debugging of compiled Prolog components embedded in other languages and tools, and running on remote machines (e.g. Web servers).
• Portable projects that can optionally include other projects.
• Automatic loading of libraries and lsx's in the Prolog listener, plus input line recall and editing.

Other standard features of the Eclipse IDE that may be useful to Amzi! users are:

• Separately downloadable plugins for developing Java, C++, COBOL, C#, PHP and other programs.
• Automatic file backup.
• Tools for modelling, graphical editing and testing.
• Seamless connection to source control systems like CVS, Perforce, PVCS, MKS, ClearCase and more.
• Tight integration with the Apache's Ant build tool.

World Class Source Code Debugger

The real jewel of the Amzi! Eclipse IDE is the source code debugger. It combines conventional debugging tools like breakpoints, pause, step-into and step-over options, with extremely clear presentation of Prolog concepts like backtracking, unification and cut.

Clarity for Learning

As a program executes, the line of source code is highlighted in different colors depending on the state at that line, making it very clear how Prolog backtracking works its way through Prolog source. A separate window has the full call stack, and, at each level the variable bindings for the clause being executed.

For the beginning Prolog programmer this means that a difficult predicate, like append/3, becomes transparent, de-mystifying the seeming magic of the rippling effects of recursion and unification.

Embedded/Remote Debugging for Production Applications

For the professional, the debugger works equally well with compiled production code, and it can be used to debug embedded Prolog components, either on the developer's workstation or running remotely on a separate machine.

This means it is no longer necessary to test and debug Prolog code separate from an integrated application. A developer can have full source code debugging at a workstation for a Prolog component running as part of a remote server environment.

Embedding Logic Services

The code boxes (below) illustrate a simple rule-based system that asks the user for a sound, from which it identifies a pet. This same idea can be used to identify problems based on symptoms, tuning parameters based on system configuration, help based on user needs, etc.

The program examples below implement 
these steps:
   Initialize Logic Server
   Load Pets program
   Get sound from user
   Assert sound to logic-base
   Query pet(X) in logic-base
   Get the value of X 
   Display results
   Close Logic Server

ls.Init("");
ls.Load("pets.xpl");
Sound.append("sound('");
System.out.println("What sound?");
while ((c=System.in.read())!=-1) 
    Sound.append((char) c);
Sound.append("')");
System.out.println(Sound.toString());
ls.AssertaStr(Sound.toString());
Term = ls.ExecStr("pet(X)");
Pet = ls.GetStrArg(Term, 1);
System.out.println("Pet is a ");
System.out.println(Pet);
ls.Close();

ls.Init("")
ls.Load("pets")
Sound = InputBox$("What sound?")
ls.AssertaStr("sound(" + Sound + ")")
Term = ls.CallStr("pet(X)")
Pet = ls.GetStrArg(Term, 1)
MsgBox "The pet is a " + Pet
Call ls.Close()

Init("");
Load("pets");
puts("What sound?");
gets(Sound);
AssertaStr("sound(%s)",Sound);
CallStr(&term, "pet(X)");
GetArg(term, 1, cSTR. &Pet);
printf("The pet is a %s\n", Pet);
Close();

ls.InitLS(''); 
ls.LoadXPL('pets');
Sound:=InputBox('','What sound?','');
ls.AssertaPStr('sound('+ Sound +')');
ls.CallPStr(t, 'pet(X)');
Pet := ls.GetPStrArg(t, 1);
ShowMessage('Pet is a ' + Pet);
ls.Close;

% 3 Prolog rules for 
% identifying pets based 
% on their sound

pet(dog) :- sound(woof).
pet(pig) :- sound(oink).
pet(duck) :- sound(quack).

?- consult(pets).
yes
?- assert(sound(woof)).
yes
?- pet(X).
X = dog

The API has 50+ methods/functions that provide both high-level and detailed access to Prolog rules, terms and data. The high-level functions use intuitive string-mapping functions that simulate a Prolog listener (see code boxes below).

The detailed functions let you construct and/or decompose arbitrarily complex Prolog terms and lists. For example, this C code pops all of the elements off a Prolog list and prints them:

while (PopList(&Lst,cSTR,S)==OK)
   printf("Popped %s\n", S);

 

"I was convinced that Amzi!'s approach to interfacing Prolog with procedural languages was the right one ... a Prolog program is fundamentally closer to a database than it is to a sequential program. As such, the API presents an interface that is similar to database interfaces ... In my mind this is as intuitive as one can get in an interface to Prolog ... Amzi! moves you toward a unique view of its positioning in the Prolog market. It aims to be a component of an application written in other languages. ...Solid, commercial grade..ideal for embedding"  PC AI Review,  Sep/Oct 95

Extending Prolog

For example, a tuning application might have its user interface implemented using C++ GUI, which loads and calls tuning rules written in Prolog. Those rules make their decisions based on the state of the machine which is determined by C functions that are called directly by the Prolog program.

Or, you might want your Prolog code to access a network server. You can use the Logic Server API to let Prolog directly access the network's API.

Extended predicates can be implemented in any language that supports the notion of call-back functions. Currently this means C/C++, Java, Delphi, C# and Visual Basic can be used for implementing extended predicates.

"I've been using Amzi! Prolog with an extensive C/C++ interface and provisions for adding Prolog predicates using C(++) code. It's wonderful." Gregg Weismann, Manager of System Software Development, Xircom, Inc.

Internet Support

• The Java class (described above) for use with JSP and Servlets (including samples).
• A .NET Class for interfacing with Microsoft's ASP.NET.
• An XML library for use with a variety of internet technologies including SOAP.
• The ability to load Prolog components from memory (thereby supporting binary archives like JAR files).
• A Logic Server Extension for communicating with clients and servers (e.g. mail, ftp, http) via Sockets.
• A CGI interface that lets you write Prolog scripts that run on web servers.

Multiple Session Support

Database Support

Tcl/Tk Graphical Interface

Unicode Support

Object Oriented Programming

For example, the pet identification code example could be encapsulated in a C++ object as illustrated in the box below.
 

// derive class from Prolog engine
class CPets: public CLogicServer {
public:
     Cpets();
     ~Cpets();
     void id(char *, char *); 
};

// constructor initializes engine and loads rules
CPets::CPets { Init(""); Load("pets");}

// destructor frees Prolog resources
CPets::~CPets { Close(); }

// identify the pet
void CPets::id(char* Sound,char* Pet) 
{
     char  buf[40];
     TERM  term;

     sprintf(buf, "sound(%s)", Sound);
     AssertaStr(buf);
     CallStr(&term, "pet(X)");
     GetArg(term, 1, cSTR, Pet); 
}


     // sample code to use CPets object
     ... 
     CPets    aPet;
     cout<<"what sound?";
     cin >> Sound;
     aPet.id(Sound, Pet);
     cout<<"The pet is a "<<Pet; 
     ...

"Combining Visual Basic and the Logic Server lets you create programs that harness the power of Prolog while Visual Basic does all the work of maintaining the interface ... creating and debugging your Prolog programs is a piece of cake ... Since Amzi!'s version is a standard implementation of Prolog, it works right out of the box with most Prolog code."  VB Tech Journal Review

Performance

Open Architecture

Your extensions can be packaged in a special type of dynamic library (DLL/SO) called an LSX (Logic Server eXtension), or they can be part of your program. LSX's are provided as part of the product for ODBC, Tcl/Tk and Sockets.

Memory Utilization

Error Handling

Portability

Prolog source and object code developed on one platform will run on any other runtime or API platform (without recompiling or relinking). This is because the Amzi! Logic Server is implemented with a virtual machine architecture similar to Java and .NET called a WAM. The Amzi! compiler and linker create binary byte-code files that can be executed by any implemention of the Logic Server.

Ease of Development

To get you started quickly, the package includes the Adventure in Prolog tutorial, the Building Expert Systems in Prolog advanced tutorial and lots of samples including:

• Hello programs for C, C++, Java, Delphi, Visual Basic, .NET, etc.
• A multi-threaded Rubik's Cube Solver.
• Clocksin & Mellish's Predicate Calculus to Prolog translator (using actual symbols for 'exists', etc.)
• A simple Japanese to English translator.
• A genealogical database implemented with ODBC.
• A general-purpose, forward-chaining expert system with a bird identification logic-base.
• An information request form for a web server.

"You guys rock... thanks for putting out excellent well-documented software!"  Oliver Jones, DotClick Corporation

Distribution

Amzi! is royalty free.

"Contact Amzi! Their Prolog products are `with-it'"  from the comp.lang.prolog newsgroup

Environments & Packaging

Amzi! Prolog + Logic Server runs under Windows, Linux, Solaris and HP/UX. (Contact us for other platforms). The product includes full HTML documentation, lots of samples, plus the tutorial texts, Adventure in Prolog and Building Expert Systems in Prolog.

Jolt Productivity Award for Components and Libraries  "Decision-making software is found in domains from securities trading to air traffic control, where choices are made based on complicated conditions, often in real time. Rule-based systems are a common solution to these types of problems. One of the best languages for creating rule-based applications has always been Prolog. However, in the past it's been difficult to create full-blown applications using it. Amzi! inc. has a solution in the Amzi! Logic Server, an embeddable Prolog rule-base and inference engine that is accessible from C++, Java, Visual Basic, Smalltalk, and other tools. With its Edinburgh-standard implementation of Prolog and cross-platform, royalty-free runtimes, the Amzi! Logic Server should make rule-based programing accessible to anyone who feels the need to make smarter software." Software Development

 

The Eclipse IDE, included in Amzi!, won the 2004 Jolt Award for Language and Development Environments from Software Development magazine.