Logtalk is an object-oriented logic programming language that can use most Prolog implementations as a back-end compiler. As a multi-paradigm language, it includes support for both prototypes and classes, protocols (interfaces), component-based programming through category-based composition, event-driven programming, and high-level multi-threading programming.Logtalk is a mature open source
object-oriented logic programming language that can use most Prolog
implementations as a back-end compiler. Logtalk main features are:
- Separation between interface and implementation
- Predicate directives (declarations) can be contained inside protocols (interfaces), which can be implemented by any object.
- Parametric objects
- Object
identifiers can be compound terms containing free variables that can be
used to parametrize object predicates. This allows us to interpret
predicate clauses as providing instantiations of a parametric object identifier. 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.
- Logtalk syntax extends 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 and can be used to
implement the concepts of pointcut and advice found on Aspect-Oriented Programming.
- 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. Categories may also extend existing objects.
Categories can be used to implement aspects and mixin-like behavior without resorting to inheritance.
- 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. Independent and-parallelism
and competitive or-parallelism are also supported. 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. .
- 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.
- Dynamic language
- Logtalk is a
dynamic language that allows hierarchies, objects, protocols,
categories, and methods (predicates) to be freely created and modified
at runtime. Other dynamic language features include support for
meta-programming and both structural and behavioral reflection.
