This site is about the object oriented iterative language Libretto. Here you can find a lot about Libretto as a query language (we call it 'small' Libretto, or Libretto 0.9).
Now we are developing a 'big' Libretto (or Libretto 1.0), a general-purpose dynamically typed language. Though having roots in Libretto 0.9, it tremendously modifies and augments the older brother in many ways. The features of Libretto 1.0 are
- The basic operator of Libretto is a 'for'–iteration (established in the language by the dot '.') – instead of the assignment '=' in other procedural languages.
- While being an object oriented language, Libretto has a functional programming kernel and supports algebraic data handling.
- Advanced iteration tools of Libretto reduce the need for heavy recursion.
- Libretto is dynamically typed, the application of its functions to objects depends on the context. Polymorphism is implemented by using functions as methods for classes and objects.
- Classes in Libretto are open: during computation new functions relevant to specific contexts can be added.
- A linear list is the basic data structure in Libretto. It is used for storing both scalar and vector values. The empty list is interpreted as 'no value'. This makes
nulland optional data types likeOptionin Scala andMaybein Haskel unnecessary. - Libretto is based on the single object space paradigm: all its objects are handled in the same way - independently of how they are physically implemented (e.g. normal program objects, objects mapped from databases, knowledge systems etc.)
- The type (object modeling) system of Libretto has strict semantics based on a description logic. It allows us to interpret a Libretto object model as a logically sound and executable knowledge description (e.g. within the Semantic Web, in formal specification descriptions, for the development of legally sound object models).
- Libretto supports distributed object models development and reusability. Libretto allows for the development of global model exchange networks.
- The basic implementation of Libretto (in JVM) supports storing objects both in memory and persistent storage devices. This feature is combined with smart garbage collecting which is capable of taking into account the peculiarities of specific objects and object cascading.
- Libretto objects can be treated in a class-like way: they can have global names, they can be declared as belonging to several classes (multiple inheritance on objects), they can have their own methods (by defining functions in objects' contexts).
- Libretto is built as a flexible syntactic system easily adaptable to specific domains without necessity of switching to other programming or markup languages. Thanks to this, Libretto can simulate domain specific languages for particular domains.
- Libretto supports optimistic parallelism based on software transactional memory (STM) techniques, which can be combined in the language with the actor model of concurrent computation.
- It is planned to supply the Libretto system with additional translators from Libretto to JavaScript, SQL etc. These translators will allow for converting the Libretto system into a platform for cloud computing (PaaS).
Libretto 0.9
is a programming language, specially developed in order to use iterations and work with objects at one time
- easy object models description
- direct object models storage
- object-iterativeness
Download last release and Libretto Language Tutorial!
Libretto Notes
is based on Libretto Engine (Java) development framework
Install Libretto Notes