OpenL demystifies a
language implementation process allowing professional programmers to decide
which language features are good and which are not for their real-world
applications. You do not have to wait for years when “big guys” will
do it for you or waste time for artificial workarounds. While OpenL
encourages developers not to be shy when a new language configuration is
required, it comes with a built-in implementation of Java known as
allows a developer to create and maintain different language
configurations. Any application today is
based on a combination of specific software packages. When we say that an
application is based on Java, we usually assume a specific version of Java
plus a set of the used Java packages with their specific versions, e.g. Java 1.4.1_02 + Xerces2.0.4.
It is enough just to
look at MDA-based or
SOA-based architectures to see an enormous number of inter-related
components of the proper language configurations. The exact
definition of the Language Configuration and other terms can be found in the
Key features for OpenL-based languages:
- Context-free grammar
- Configurable business context
- Open type system
- Strong type checking.
Each language configuration is specified explicitly by its
name and consists of three key components: Parser, Binder and Virtual
Machine. Here is the OpenL Functional Model:
OpenL Language Configuration
1) Context-free grammar that
specifies a language syntax. The grammar Parser parses an OpenL code and
creates a valid syntax tree (or points to an error) without knowing yet an
2) Configurable binding context that defines data
types. Based on a context, the Binder assigns types to all elements of the syntax tree and
makes sure that all used operations are valid in this particular context. It
converts the syntax tree into semantic tree.
3) Virtual Machine (similar to JVM) executes the semantic tree in
Along with a strong type checking facility, this approach allows an OpenL to
access directly objects defined in different sources such as Java, MS Office files,
DB, XML including XML Schema, WSDL, RDF, etc. You may use familiar Java syntax
to deal with objects defined in an XML file, in an Excel spreadsheet, or in
an SQL table as if they were a described in a Java class without necessity
to create such classes. No intermediate Java classes are generated either.
Moreover, the same OpenL code can naturally work with objects coming from
different object sources without knowing their origin.
themselves are implemented using Java. As a result, it does not matter how
limited your particular configuration of an OpenL language is, you always
can add to this configuration any existing Java package to take advantage of
the existing Java class library.
OpenL can be used as a
foundation for a powerful development environments that require pieces of
Java-like code to be maintained outside traditional Java IDEs. Original developers of OpenL have used it to create the first full-scale Business Rules Management
Framework OpenRules. We expect that the
proper development teams will use OpenL (instead of fighting with a pure
Java) to implement a workflow management framework such as
BPELJ, Web application development, database management, software
configuration, and other practical frameworks.