L is for ...

leoHTML

is a HTML precompiler for static home page generation. It detects special HTML tags in your page and generates HTML code out of it.
It supports:

• file including
• soft and hard macros
• menu tree handling
• image size detection
• file link generation with reguar expression support
• multiple languages page generation with character support
• frames
• dynamic code generation via a javascript interpreter
• customizeable init system
• user tag definitions

little

is a new programming language, looking like LISP, but pure Object-Oriented. It is called LITTLE, because it, in the origin, has been planned to be as small and customizable as possible to serve as an extension language. It's current implementation, however, is not that little ...

• Dynamically Typed - LITTLE doesn't use explicit type declarations object classes are determined at runtime
• Multiple Inheritance - classes may have multiple parent classes attributes of common base classes are always inherited once, ambiguities in method inheritance must be explicitly resolved
• Everything Is Object - classes are first-class objects, as are 'atomar' types like Symbol, Char, Int class methods are fully polymorphic
• Exception Handling
• Garbage Collection - the programmer doesn't have to take care of memory deallocation the system automatically detects and collects unreferred objects
• Built-in Support for DSOs and late binding
• Native classes and methods - LITTLE offers features for efficient integration of code written in C/C++ (or other compiling languages)
• Optional support for native threads and asynchronous signals

L.in.oleum

(Low-level INterfaced OverLanguage for Extremely Universal Machine-coding) is a lightning fast programming language for everyone who wants to be immune from future system changes. It features complete abstraction from the physical system, yet its applications' speed is closely comparable to that of pure machine language, with an almost 1:1 language-to-CPU instruction ratio. You may think about it as of some sort of Java, but running in low level, and creating stand-alone applications, or you may try to compare it to Forth, but in the end you'll probably find it's very difficult to find LINOLEUM equivalents in any other existing languages; as far as I know, it is unique, it could even be a missing ring in the history of informatics. LINOLEUM gives you an APA (All Pixels Addressable) display to output truecolor graphics controlling and writing every single pixel, as if you were programming in assembly and accessing a linear frame buffer; it gives you the possibility to build your own waveforms and leaves your program the duty (and advantage) of sequencing, even in real time, the samples straight into the program's memory, to playback them upto 44.1KHz over two channels (stereo); it treats the printer as an additional display, where WYSIWYG really means What You See Is What You Get. Combining all this, you can write your own Graphical User Interface, your own graphics engine (and with enough power to perform 3D rendering in real time without absolutely using hardware acceleration, entirely via software), your own digital audio sequencer, and a lot more. It's a REAL cross-platform assembler, and barely the world's fastest cross-platform programming language.

LHDL

-- while not yet a hardware description language, may be seen as the first step in that direction.

LcompScript

- The Lcomp Scripting Engine is a scripting engine written in Visual BASIC for DOS 1.0 that can be used by a programmer to write automatated scripts to perform routine actions in DOS. It can be used as a simple automation tool or a vast programming language

Lemick

is a programming language with BASIC syntax, it's a typed and a compiled language, its source is compiled into a platform-independent virtual machine assembler that is later transformed into a platform-dependent representation by the just-in-time compiler. Lemick supports concurrent and distributed programming (multi-threading and distributed multi-threading). Rendezvous are used for message passing; replicas and ultra-weak consistency model implement distributed shared memory simulation. Extension of exception handling mechanism, including distributed version is being developed now. Lemick favors mixed procedural and object-oriented programming style.

Leopard

makes it incredibly easy to start programming your own software. There are so many languages out there that can be too complicated and too confusing for a beginner to grasp. Leopard simplifies the process, making programming easy and fun.
My goal with Leopard is to spark your interest in programming software, and hopefully this will lead you to expanding your skills with other languages. Leopard will get you up and running in very little time, and I hope it's an enjoyable experience for you.

Libra

is a relational programming language that explores the different values yielded by relations by back-tracking rather than parallel execution.
Ordinary programming languages calculate functions. Sometimes a function is inappropriate. For example, 4 has two square roots, +2 and -2, but an ordinary programming language provides a sqrt function that returns only one of the roots. So if we want to find both roots of a quadratic equation, we have to deal with each root separately. In a relational language, we need only to specify one solution, and the program will find both. This is because it will treat sqrt as a binary relation. A binary relation is similar in concept to a function, but can map an argument to any number of values (including zero).

Relations have many uses in computer science. The Z Specification Language makes heavy use of relational algebra notation. One reason is that programs are usually required to establish an input-output relationship, but there are often many outputs that are allowable. For example, a program may be asked to find any solution to a problem, or it may be asked to list all solutions, but in no particular order. A functional specification is bound to specify some particular solution or some particular order. A functional specification is usually an over-specification.

Lingo

makes it easy to learn to program for Windows. If you're new to programming, you can download Lingo and write your first program very easily. And experienced programmers benefit because Lingo is quick to install and simple to use! Lingo includes a Developer Environment for designing forms, managing projects and debugging.

LogTalk

is an Open Source object-oriented extension to the Prolog programminglanguage providing the following features:

Separation between interface and implementation

Predicate directives (declarations) can be contained inside objects or inside protocols (interfaces), which can be implemented by any object.

Parametric objects

Object names can be compound terms containing free variables that can be used to parametrize object predicates.

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).

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++.

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 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.

Event-driven programming

Predicates can be implicitly called when a spied event occurs, thus minimizing object coupling.

Component-based programming

Predicates can be encapsulated inside categories, which can be imported by any object.

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.

Good performance

Logtalk code is compiled using the same technics that you use to write efficient Prolog code. In addition, method lookups are cached by the Logtalk runtime engine, 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 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.

Lush

is an object-oriented programming language designed for researchers, experimenters, and engineers interested in large-scale numerical and graphic applications. Lush is designed to be used in situations where one would want to combine the flexibility of a high-level, weakly-typed interpreted language, with the efficiency of a strongly-typed, natively-compiled language, and with the easy integration of code written in C, C++, or other languages.