Logtalk is a mature Open Source object-oriented logic programming language that can use most Prolog implementations as a back-end compiler.
Here are some key features of “Logtalk”:
Separation between interface and implementation
· Predicate directives (declarations) may be contained inside protocols (interfaces), which may be implemented by any object.
Parametric objects
· Object names can be compound terms containing free variables that can be used to parametrize object predicates. This allows us to treat any predicate as an instantiation of a parametric object. I.e. through parametric object we can associate any number of methods with a compound term.
Support for both class-based and prototype-based systems
· You may have, in the same application, class-based hierarchies (with instantiation and specialization relations) and prototype-based hierarchies (with extension relations). Moreover, fundamental language features such as protocols (interfaces) and categories (components) can be used simultaneously by classes, instances, and prototypes.
Support for multiple object hierarchies
· No need to be constrained to a single, lengthy hierarchy rooted in some generic object.
Private, protected, and public inheritance
· Logtalk supports private, protected, and public inheritance in a way similar to C++. Moreover, any entity relation can be qualified using a scope keyword. E.g. an object can privately implement a protocol, thus making all protocol declared predicates private.
Private, protected, and public object predicates
· Set the scope of your object predicates to match your protocol design and let the runtime system enforce your choices.
Static and dynamic objects
· Objects can be either static or dynamic. Static objects are defined in source files which are compiled and loaded in the same way as Prolog files. Dynamic object can be either defined in source files or created at runtime.
Static and dynamic object predicates
· Any static object may contain both static and dynamic predicates.
A pre-processor so we can use standard Prolog syntax
· Logtalk uses standard Prolog syntax with the addition of a few operators and directives for a smooth learning curve. Prolog code can be easily encapsulated inside objects with little or no changes. Moreover, Logtalk can transparently interpret most Prolog modules as Logtalk objects for easy reusing of existing code (e.g. libraries).
Event-driven programming
· Predicates can be implicitly called when a spied event occurs, allowing programming solutions which minimize object coupling. In addition, events provide support for behavioral reflection.
Component-based programming
· Predicates can be encapsulated inside categories, which can be virtually imported by any object, without any code duplication and irrespective of object hierarchies. Thus, objects may be defined through composition of categories, which act as fine-grained units of code reuse.
Multi-threading programming
· High level multi-threading programming is available when running Logtalk with selected back-end Prolog compilers, allowing objects to support both synchronous and asynchronous messages. Easily take advantage of modern multi-processor and multi-core computers without bothering with the details of creating and destroying threads, implement thread communication, or synchronizing threads.
Multi-inheritance support
· Logtalk supports multi-inheritance of both protocol and implementation. An object may implement several protocols and extend, specialize, or instantiate several objects. Multi-inheritance conflicts are solved implicitly by the Logtalk lookup algorithms or explicitly by using predicate directives.
Good performance
· Logtalk code is compiled using the same technics that you use to write efficient Prolog code. In addition, Logtalk supports both static binding and dynamic binding (with method lookup caching), greatly improving performance. Benchmark results for some Prolog compilers are available here.
Close integration with the ISO Prolog Standard
· Logtalk is designed for smooth integration with any Prolog compiler that conforms or closely follows the ISO Prolog Standard.
Compatible with most Prolog compilers
· Logtalk interfaces with a specific back-end Prolog compiler via a minimal configuration file making it compatible with almost any modern compiler.
Automatic generation of XML documentation files
· Logtalk automatically generates a documentation file in XML format for every compiled object, protocol, or category. The system includes all the necessary XSL(T) files and scripts to convert documenting files to (X)HTML and PDF.
Requirements:
· Prolog
What’s New in This Release:
· Allow the argument of {}/1 calls to be a variable at compile time.
· Updated the Qu-Prolog config file to match and require version 8.1 and added a ‘qplgt’ integration script.
· Updated the XSB config file to match and require version 3.1 and to take advantage of the compiler option optimize/1 when loading Logtalk generated Prolog intermediate files.
· Added a new library object, ‘lgtunit’, providing preliminary support for writing and running unit tests. Added a new example, ‘testing’, defining sample unit tests.
· Added a new multi-threading example,’threads/tak’, implementing the Takeuchi function (recursive arithmetic).
· Updated the ‘threads/philosophers’ example to use notifications instead of a dynamic predicate for representing chopstick availability. Added an alternative implementation using a parametric object. Improved example documentation.
· Updated the ‘benchmarks’ example to allow comparisons between calls to imported category predicates and calls to local object predicates.
· Updated Emacs support in order to fix problems with the syntax-coloring of some Logtalk built-in predicates and applied a patch contributed by Nicolas Pelletier to workaround a compatibility problem with XEmacs.
· Updated jEdit support in order to fix a problem with the syntax-coloring of the :/1 control construct.