1. Visual Prolog 9 Tutorials
2. Visual Prolog 5.2
3. Visual Prolog Ide Download
4. Visual Prolog Download

Visual Prolog is a powerful and type safe high level programming language combining the very best features of logical, functional and object-oriented programming paradigms in a consistent and elegant way. With Visual Prolog you can build applications for the Microsoft Windows 32/64 platforms. It supports advanced client-server and three-tier. Visual Prolog Click the Download Free Trial button above and get a 14-day, fully-functional trial of CrossOver. After you've downloaded CrossOver check out our YouTube tutorial video to the left, or visit the CrossOver Chrome OS walkthrough for specific steps.

In this tutorial, we will introduce a program that is developed on the Visual Prolog platform. The essential algorithms of the tutorial are the same as those that were developed in Fundamental Prolog Part 2.

• 1Differences between Visual Prolog and traditional Prolog
  • 1.1Program Structure Differences
• 2A Full Fledged Example: family1.vipprj

Differences between Visual Prolog and traditional Prolog

Visual Prolog 7.3.7302 7.4.7402 file size: 28.92 MB Visual Prolog is a powerful programming language combining the features of logical, functional and object-oriented programming. Visual Prolog is a logical programming language that counts PDC Prolog and Turbo Prolog as predecessors. The goal of Visual Prolog is to support industrial. Enter to Search.

The differences between traditional Prolog and Visual Prolog can be broadly divided into these categories:

• Program structure differences: There are distinct, yet easy to understand differences between the structure used in traditional Prolog and that used in Visual Prolog. It essentially comprises of understanding how to mark out the declarations from the definitions, and to indicate the main Goal that the program has to seek using specific keywords.

• File considerations: Visual Prolog provides various facilities to organize the structure of the program into different kinds of files.

• Scope access issues: A Visual Prolog program can pick up functionality developed in other modules using a concept called scope identification.

• Object orientation: A Visual Prolog program can be written as an object-oriented program, using classic object oriented features.

Program Structure Differences

Declarations and Definitions

In Prolog, when we need to use a predicate we simply do so without any prior indication to the Prolog engine about our intention. For example, in the earlier tutorial the grandFather predicate's clause was directly written using the traditional Prolog predicate head and body construction. We did not bother to inform the engine in the code that such a predicate construction is to be expected later.

Similarly, when a compound domain is used in traditional Prolog, we can use it without first warning the Prolog engine about our intention to use the domain. We simply use a domain the moment we feel the need for it.

However, in Visual Prolog, before writing the code for the clause body of a predicate we first need to declare the existence of such a predicate. Similarly, before using any domains, they need to be declared. The reason such forewarnings are required in Visual Prolog is to ensure that runtime exceptions are converted into compile time errors as far as possible.

By 'runtime exceptions', we mean issues that turn up when a program is run. For example, if you had intended to use an integer as the argument of a functor, and instead of the integer you had erroneously used a real number, it would become a runtime error in programs written using most other Prolog compilers and the program would fail there. When you declare the predicates and domains in advance, this kind of positional grammar (which argument belongs to which domain), etc. is made available to the compiler. Therefore, when Visual Prolog performs a compilation, it checks the program quite thoroughly to weed out such grammatical and other mistakes.

Because of this feature in Visual Prolog, the overall efficiency of a programmer improves. The programmer does not have to wait till the program is actually executed to detect a bug. In fact, those of you who are experienced in programming would understand what a life-saver this can be; often, the particular sequence of events that causes a runtime exception to happen may be so elusive that the bug may only turn up after several years, or it may manifest itself in some critical or other embarrassing situations!

All this implies that the compiler has to be given explicit instructions regarding the predicates and domains that exist in the code using appropriate declarations before they are defined.

Keywords

A Visual Prolog program consists of Prolog code which is punctuated into different sections by appropriate keywords that inform the compiler the code it has to generate. For example, there are keywords that differentiate the declarations from the definitions of predicates and domains. Usually, each section is preceded by a keyword. There is normally no keyword which signifies the ending of a particular section. The presence of another keyword indicates the ending of the previous section, and the starting of the next one.

The exception to this rule, are the keywords 'implement' and 'end implement'. The code contained between these two keywords indicates the code to be used for a particular class. Those of you who do not understand the concept of a 'class' can, for now, think of it as a module or a section of the overall program code.

For the purpose of this tutorial, we'll introduce only the following keywords (given below). We are also giving the purpose behind these keywords, and the actual syntax can be easily learnt from the documentation. There are other keywords also in Visual Prolog, and those can easily be picked up in later tutorials and the documentation.

The list of the keywords that you need to know in this tutorial is the following:

implement and end implement

Among all the keywords discussed here, this is the only one, which exists as a pair. Visual Prolog treats the code written between these two keywords as the code that belongs to one class. The name of the class MUST be given after the implement keyword.

open

This keyword is used to extend the scope visibility of the class. It is to be used just after the implement keyword.

constants

This keyword is used to mark a section of the code that defines some commonly used values in the program code. For example, if the string literal 'PDC Prolog' is to be used in multiple locations throughout the code, then you can define a mnemonic (a short-form, easily remembered word) for the same thus:

Note that the definition of a constant ends in a period (.). Unlike a Prolog variable, a constant should be a word starting with a lower case letter.

domains

This keyword is used to mark a section declaring the domains that would be used in the code. There are many variations for the syntax of such domain declarations, and they cater to the all the possible kinds of domains that would be used later on in the code. As this tutorial is a basic one, we shall not get into the finer details of the domain declarations that can be possible.

To summarize here, you would be declaring the functor that would be used for the domain and the kind of domains that would form its arguments. Functors and compound domains were explained in detail in the previous part of the Tutorial.

class facts

This keyword designates a section, which declares the facts that would be used later on in the code of the program. Each fact is declared with the name used to signify the fact and the arguments that are used for the respective facts along with the domains that those arguments belong to.

class predicates

This section contains the declarations of the predicates that would be later defined in the clauses section of the code. Once again, the names that would be used for these predicates along with the arguments and the domains, to which the arguments belong to, would be indicated in this section.

clauses

Of all the sections that are present in a Visual Prolog code, this section is the one that closely mimics a traditional Prolog program. It contains the actual definitions of the previously declared predicates. And you would find that the predicates used here would follow the syntax as declared in the class predicates section.

goal

This section defines the main entry point into a Visual Prolog program. A more detailed explanation is given below.

Goal

In traditional Prolog, whenever a predicate is defined in the code, the Prolog Engine can be instructed to start the code execution from that predicate onwards. However, that is not the case with Visual Prolog. Being a compiler it has the responsibility of producing efficiently executing code for the program you write. This code would not be actually executing at the same time the compiler is doing its work. Hence, the compiler needs to know beforehand the exact predicate from which the code execution would start, so that later on when the program is called to perform, it can do so from the correct starting point. As you may have guessed, the compiled program can run independently without the Visual Prolog compiler or the IDE itself.

In order to do that, there is a special section indicated by the keyword Goal. Think of it as a special predicate that you would write without arguments. That predicate is the one from which the entire program execution will start.

File Considerations

Many times, it may become cumbersome to put all the parts of the program into one file itself. It may even make the program unreadable and sometimes incorrect. Visual Prolog has the capability of dividing the program code into separate files using the IDE (Integrated Development Environment) and it is possible to write neat pieces of code into separate files using that IDE. When it is done in that manner, things that are to be used commonly can be accessed across files. E.g. If you have a domain that is to be used in multiple files, then the declaration of that domain is done in a separate file, and that file is then accessed from other files.

However, for the purpose of simplifying this particular tutorial, we shall predominantly be using only one file to develop the program code. In the course of constructing the program, the IDE would automatically create some more files which we can ignore for the time being. We can learn about them in future tutorials.

Scope Access Issues

Visual Prolog divides the total program code into separate parts, each part defining one class. In object oriented languages, a class is a package of code and its associated data which is put together. This requires more explanation which would be available in later tutorials. As noted earlier, for those of you who are not familiar with object oriented programs, you can think of a class loosely as being synonymous to modules. Normally, Visual Prolog defines each class in its own separate file.

During the program execution, it often so happens that the program may need to invoke a predicate that is actually defined in another class (file). Similarly, data (constants) or domains defined in a class may need to be accessed from a different file.

Visual Prolog allows such cross class code/data references using a concept called scope access. This can be understood by an example. Suppose there is a predicate called pred1 defined in a class called class1 (which is written down in another file using the IDE), and we need to call that predicate in the clause body of some other predicate, pred2 in a different file (say class2) then this is how pred1 would be called within the clause body of pred2 :

In the above example, you can see that the clause body of pred2 calls two predicates pred1 and pred3. As pred1 is defined in another file (which defines class1), the word class1 with the token :: (two colons) precedes the word pred1. This can be called as a class qualifier.But the predicate pred3 is defined within the same file as pred2 itself. Hence there is no need to indicate class2:: prior to the predicate call for pred3.

This behavior is technically explained thus: The scope visibility of pred3 is within the same scope of pred2. Hence there is no need to clarify that pred3 is from the same class as pred2. The compiler would automatically look for the definition of pred3 within the same scope area as defined for class2.

The scope area of a particular class definition is restricted to the class that is implemented in a particular file (i.e. code that is written within the implement - end implement keywords). The predicates defined therein can call each other without the class qualifier and the double colon (::) token preceding it.

The scope area of a class can be extended by using the open keyword. This keyword informs the compiler to bring in names (of predicates / constants / domains) that were defined in other files. If a scope area is extended, then we need not write the class qualifier with the double colon.

Object Orientation

The current version of Visual Prolog is a strongly object oriented language. The ENTIRE code which is developed for a program is put into appropriate classes, as needed. This happens by default, even if you are not interested in the object oriented features of the language. You would notice this feature in the example given in this tutorial also. The code is inserted into a class called 'family1' even though we would eventually not use any objects created from that class. Instead, we would use publicly accessible predicates of the code within that class directly.

This tutorial will not handle the object oriented features of the language. Future tutorials would extend this concept, and even actually use the object oriented features.

A Full Fledged Example: family1.vipprj

The result of following this tutuorial is available as an example in the Visual Prolog installation, use Help -> Install Examples... to install the examples. This particular example is then in the folder: '…_tutorialfamilyfamily1', where '…' is the folder in which you installed the examples.

Here we will however create it from scratch.

Let us now put all the knowledge we've gathered together to create our first Visual Prolog program. This will contain the same basic logic that was explored in the Tutorial 'Fundamental Prolog. Part 2'. All the code that is to be written for this tutorial is shown below. The actual code writing will be done using the Visual Prolog IDE (Integrated Development Environment). There are some more files that are needed for the tutorial, but those would automatically be generated and maintained by the IDE. The step by step instructions (using screenshots) for utilizing the IDE to develop the program will shortly follow.

But first of all, let us acquaint ourselves with the main code of the program:

Step 1: Create a New Console Project in the IDE

Step 1a. After starting the Visual Prolog IDE, click on the New menu item from the Project menu.

Step 1b. A dialog would be presented to you. Enter all the relevant information. Ensure that the Project Kind is Console and NOT GUI.

Step 2: Build an Empty Project

Step 2a. When the project is just created, the IDE would display the following project window. At this point in time, it does not have any clue about what files the project is dependent on. It does, however create the basic source code files for the project.

Step 2b. Use the Build menu item of the Build menu, to compile and link the empty project to create an executable file which basically does not do anything. (At this point it time, it would not generate any errors either)

While building the project, take a look at the messages that are dynamically displayed in the Messages window of the IDE. (In the case the Messages window is not visible, you can turn it on using the Window menu of the IDE) You will notice that the IDE intelligently pulls in ALL the necessary PFC (Prolog Foundation Classes) modules into your project. PFC classes are those classes which contains the basic functionality on which your programs would be built.

Step 3: Populate the main.pro with the Actual Code

Step 3a. The default code inserted by the IDE is very basic and does not do anything useful. You would need to delete the entire code and copy and paste the actual code of main.pro (given in this tutorial) into that window.

Step 3b. After you perform the copy-paste operation, the main.pro window would now look as shown below:

Step 4: Rebuild the Code

Re-invoke the Build menu command, and the IDE will notice that the source code has changed, and will take measures to appropriately recompile the correct sections. If you use the Build All menu command, then ALL the modules would be recompiled. For large programs this can consume some time. Build All is often used ONLY at the end of a series of smaller compilations; just to ensure that everything is in ship-shape order.

During the Build process, the IDE not only does the compilation; but it also determines whether the project may need any other missing PFC modules, and inserts those and re-starts the compilation process if required. This can be seen in the messages appearing in the Messages window, where you'll notice the IDE was forced to build the project twice because of some additional include statements.

Step 5: Execute the Program

We now have our first true application complied using Visual Prolog. In order to test the application we've just compiled, you can run the program using the Build -> Run menu command. However, in our case this would result in an error. The reason is that our little program is trying to read a text file (fa.txt) for its functioning. That text file contains the actual data regarding persons which our program will process. We'll come to the syntax of that file a bit later.

We need to now write that text file using some text editor and place it in the same directory where the executable is now residing. Normally, the executable would reside in the sub-folder called exe from the main project folder.

You cannot create such a file directly in the IDE itself, but you can save an existing files with a new name (using File -> Save as ...) and then edit that file. Give the file the name fa.txt. After you have saved the file you can add it to the project by selecting File -> Add.... The advantage of adding it to the project is that it will be available for any subsequent debugging, etc.

The contents of the file should be as follows:

Though it is a data file, you would notice that the syntax of the file is VERY similar to regular Prolog code! Even though the program is now compiled and is now in a binary format; you can change the output by simply changing the crucial data the program is processing. And that data is written into this text file using the same syntax as Prolog. Thus Visual Prolog emulates the dynamic code writing capability of traditional Prolog. Albeit, not all features are available but at least complicated domains such as those in this example can definitely be given.

The syntax used in fa.txt MUST be compatible with the domain definitions of the program. E.g. The functor used for defining a person MUST be person and not anything else; else appropriate compound domain representing that functor would not get initialized. (We had covered the topic of functors and compound domains in an earlier tutorial).

Now, when you run the program using the Build -> Run in Window menu command, this is what you'll see:

The program processes the information in the file fa.txt and works out the logical sequence of the parentages of people given there.

A Round up of the Program

The logic of the program is very simple. We had discussed it in an earlier tutorial, where we explained how the correct representation of data can help yield the appropriate results in a Prolog program. Let us now discuss the manner in which this logic works.

Visual Prolog 9 Tutorials

At start up, the main predicate will be invoked directly. This in turns branches off to the run predicate. The first thing the run predicate will do is to read in the data which is written in the file fa.txt. Once the data is in place, the program systematically progresses from one test to another to process the data and write out the conclusions of that test onto the console.

The mechanisms for processing the data are standard mechanisms of backtracking and recursions. This tutorial is not the place for a detailed explanation of how Prolog works, but here is a short summary of the internal workings.

When the run predicate is calling the father predicate, it does not stop at the first satisfactory ending of the father predicate. The invoking of a fail at the end of the predicate, forces the Prolog engine to seek another pass through the father predicate. Such a behavior is called backtracking, because the Prolog engine literally seems to backtrack over code which had earlier executed.

This happens recursively (i.e. as a repetitive process or cyclically), and at each cycle the father predicate yields the next result. Eventually all the possible definitions of 'fathers' given in the data are exhausted, and the run predicate would have no choice but carry over to the next clause body of the run predicate.

The father predicate (as well as some other predicates) has been declared to be non-deterministic. The keyword nondeterm can be used to declare non-deterministic predicates; i.e. predicates that can yield multiple answers using backtracking.

If the no keyword is used in a predicate declaration, then the predicate has got the procedure mode, which can give only one solution, and the father predicate will stop after yielding the first result and cannot be re-entered into. Also, one must be careful in the usage of the cut (!) in the clause bodies of such non-deterministic predicates. If there is a cut at the end of the clause body of the father predicate, yet again; the predicate will yield only one solution (even if it has been declared to be non-deterministic).

The anyflow flow-pattern tells the compiler that the parameters that are given for the predicate could be either free or bound, with no restrictions whatsoever. That means, with the same definition of the father predicate, it would be possible to both yield the father's name (in case the name of the offspring was bound) OR the offspring's name (in case the name of the father was bound). It can also handle situations where both are bound; in which case the predicate will check if such a relationship exists in the data.

And; to state the obvious; the anyflow flow pattern can also accommodate a situation where both the parameters of the father predicate are free variables. In such a case, the father predicate will yield the various combinations of father+offspring present in the data the program has learnt (through consulting the fa.txt file) to the enquirer. The last usage is what is performed in the run predicate, as seen in the code snippet below. You would notice that the variables X and Y given to the father predicate are not bound when the father predicate is called.

Conclusion

In this lesson we learnt that programs written in Visual Prolog are often very similar to those written in traditional Prolog. There are several keywords that are used to differentiate the various parts of a Visual Prolog source code. Though Visual Prolog is an object-oriented language, it is possible to develop code which avoids the language's object-oriented features. A complete console-based application (family1) was developed in this tutorial, which explains, how to create such a program.

We also found that it is possible to emulate the dynamic working of a traditional Prolog program by keeping part of the code as a data file outside the main binary compiled application. The syntax of such a data file closely follows Prolog syntax.

References

The following Comparison of Prolog implementations provides a reference for the relative feature sets and performance of different implementations of the Prolog computer programming language.

Portability[edit]

There are Prolog implementations that are radically different, with different syntax and different semantics (e.g. Visual Prolog)^[1] and sub-communities have developed around different implementations.^[1]

Code that strictly conforms to the ISO-Prolog core language is portable across ISO-compliant implementations. However, the ISO standard for modules was never accepted by most Prolog implementors.^[1]

Factors that can adversely affect portability include: use of bounded vs. unbounded integer arithmetic, additional types such as string objects, advanced numeric types (rationals, complex), feature extensions such as Unicode, threads, and tabling.^[2] Use of libraries unavailable in other implementations and library organisation:^[1]

Currently, the way predicates are spread over the libraries and system built-ins differs enormously. [...] Fortunately, there are only few cases where we find predicates with the same name but different semantics (e.g. delete/3)

Main features[edit]

Operating system and Web-related features[edit]

Static analysis[edit]

Optimizations[edit]

Release[edit]

Benchmarks[edit]

Visual Prolog 5.2

• Benchmarking issues: Odd Prolog benchmarking, Performance differences.^[4]
• Benchmarking software: older, Dobry^{[permanent dead link]}, Aquarius benchmark suite, (Bothe, 1990),^[5](Demoen et al. 2001), benchmark descriptions
• Benchmarking results: B-Prolog, SICStus, XSB,^[6] SICStus vs Yap vs hProlog^[7]
• Benchmarking results: Survey of java prolog engines by Michael Zeising
• Benchmarking results: OpenRuleBench yearly open-source benchmark of rule engines

References[edit]

1. ^ ^abcdWielemaker, J.; Costa, V. T. S. (2011). 'On the Portability of Prolog Applications'. Practical Aspects of Declarative Languages. Lecture Notes in Computer Science. 6539. p. 69. CiteSeerX10.1.1.1030.9396. doi:10.1007/978-3-642-18378-2_8. ISBN978-3-642-18377-5.
2. ^Jan Wielemaker and Vıtor Santos Costa: Portability of Prolog programs: theory and case-studies. CICLOPS-WLPE Workshop 2010.
3. ^ ^abC/Java interface can also be used for graphics and OS control.
4. ^B. Demoen, and P. Nguyen, About unnecessary performance differences between Prolog implementations, Proceedings of the Colloquium on Implementation of Constraint and Logic Programming Systems (CICLOPS 2001)
5. ^Bothe, K. (1990). 'A prolog space benchmark suite'. ACM SIGPLAN Notices. 25 (12): 54–60. doi:10.1145/122193.122197.
6. ^A Summary of XSB Performance (1993)
7. ^Demoen, B.; Nguyen, P. L.; Vandeginste, R. (2002). 'Copying Garbage Collection for the WAM: to Mark or Not to Mark?'. Logic Programming. Lecture Notes in Computer Science. 2401. pp. 194–208. CiteSeerX10.1.1.13.2586. doi:10.1007/3-540-45619-8_14. ISBN978-3-540-43930-1.

External links[edit]

Visual Prolog Ide Download

• Overview of Prolog Systems by Ulrich Neumerkel

Visual Prolog Download