Free generic programming techniques software for linux

Felix is an advanced Algol like procedural programming language with a strong functional subsystem. It features ML style typing, first class functions, pattern matching, garabge collection, polymorphism, and has built in support for high performance microthreading, regular expressions and context free parsing.

The system provides a scripting harness so the language can be used like other scripting languages, but underneath it generates native code to obtain high performance.

A key feature of the system is that it uses the C++ object model, and provides an advanced binding sublanguage to support integration with C++ at both the source and object levels, both for embedding C++ data types and functions into Felix, and for embedding Felix into exitsing C++ architectures.

The Felix compiler is written in Objective Caml, and generates ISO C++ which should compile on any platform.

The Hecl Programming Language is a high-level scripting language implemented in Java. Hecl Programming Language is intended to be small, extensible, extremely flexible, and easy to learn and use.

Hecl is intended as a complement to the Java programming language, not a replacement. As such, it tries to do well what Java doesnt, and leaves those tasks to Java for which it is best suited.

Hecl aims to be a very immediate language - you can pick it up and start doing useful things with it quickly. It is also meant to be easy to learn. Where Java is verbose and rigid, Hecl is forgiving and quick to write. For instance, System.out.println("Hello World"); vs puts "Hello World" - 41 keystrokes (shifted letters count double) versus 22. Hecl is built to "scale down".

This makes Hecl ideal for large applications written in Java that would like to provide a user friendly scripting interface, rather than, say, a clunky XML based configuration system.

Hecl is also a small language with a minimal core. The idea is to provide only whats necessary in the language itself, and as needed, add in extensions for specific tasks.

Core Hecl is small enough to run on my Nokia 3100 cell phone as a J2ME application, presenting the interesting possibility of writing scripts, or at some point, maybe even scripting entire applications, for devices running embedded Java. As an example, you can try this MIDlet: Hecl.jar Hecl.jad

The Blue Programming Language project is a unique bytecode-compiled language that implements the most effective capabilities of many popular programming languages in a clear and concise syntax. Plugin modules are easy to develop and can add functions, types, and even programming paradigms to the language without interfering with the syntax.
Blue is still early in its early development stage so very little optimization has been done, and its functionality grows every day. The following introduction is by no means a comprehensive description of blues capabilities.
Main features:
- Free (GPLd)
- A cross-platform programming language
- A dynamic language with a simple and consistant syntax
- Bytecode compiled
- Garbage collected
- Incredibly easy to expand with native functionality
Installation:
- Download the source
- Extract the archive. "tar -xvzf blue1.0.tar.gz"
- cd into the extracted directory. "cd blue"
- Execute make. "make"
- su to root. "su root"
- Execute make install 1. "make install"
- Execute make test. "make test"
Replace "make install" command with "make install INSTALL_DIR="/different/dir" to install to an alternate location.
Enhancements:
- This update contains a compiler bugfix, many more tests, and a function call optimization.

PATH is a very different programming language than what you are probably used to if youre an average programmer. If youve programmed in the language Brainf*ck, youll recognize the memory cell architecture. Also, Befunge programmers will recognize the two-dimensional way that PATH programs are laid out.

PATH programs are laid out on a two-dimensional grid. It follows a path of instructions on the program grid, turning 90 degrees when instructed to (hence the name). A character recognized by the interpreter is called an instruction symbol.

To show you what a PATH program actually looks like, heres a simple program that coincidentally spells out the word "PATH" in large ASCII art letters. (You may recognize it from the PATH program homepage, and its also included with the interpreter.) All it does is make the console beep. Ill explain it in detail later, once you know what all the instruction symbols do.

The interpreter starts at the first "$" symbol it finds and starts heading right. Every time it encounters a valid instruction symbol, it executes it. When it encounters certain special symbols, it may turn in another direction.

The interpreter keeps going until it reaches a "#" symbol. If it encounters a character that is not a valid instruction symbol, it ignores it and skips over it.

KDE Simple Programming Tutorial is a tutorial for developing a KDE application.

With the only requirement of a little C++ knowledge, and using the latest KDE snapshots, the reader will learn how to build his/her first KDE application from a simple "Hello world" button to a Web browser with a DCOP interface that communicates with a bookmark application running in a separate process.

Theres also a spanish and a romanian version of the documentation.

Qu is a powerful full-featured object oriented programming language. It is an Open Source software. The Qu Programming Language is absolutely free (as in free lunch) and distributed under the GNU General Public License (GPL).
Qu is inspired by other languages. Most noticeably Perl, Python, Ruby and C. It mostly resembles Python except that the syntax is more flexible, the internals are simpler, and Qu allows you to use either indentation or non-indentation style.
Qu has a clean syntax designed to promote readability. There is no need for semi-colons and commas to separate items except in rare cases when the end of an expression is not obvious.
Qu is a procedural language. A program consist of statements and expressions evaluated in the order they appear.
Qu is a strong semi-dynamic (optional-static) typing language. Adding a number to a string will throw an exception. A variable can hold anything or you can attach a validator to it. Validators can be as simple as a class, a constant object (Array, Range, Struct, etc.) or even a validator function.
Arrays, dictionaries, and sets can be constrained to hold only a specific "type" of data as well.
Everything in Qu are objects, including numbers, strings, etc. The number 123, for example, is actually an instance of the builtin Int class. Classes are instances of the builtin Class class, etc. But this does not mean that you must write your programs in an object oriented manner. That is entirely up to you.
Documentation can be embedded in the source code. The compiler will skip them. The documentation builder will extract them. The builder is included as part of the standard distribution.
In fact, when you install Qu or Qu modules, the documentations are automatically built for you.
Qu is entirely written in C. Readable documentations are embedded in the C sources directly.
Writing C modules for Qu is as easy as it can get!
Main features:
- fast
- clean syntax
- strong semi-dynamic typing
- module management
- multithread
- deadlock detection
- label loops, break, continue, redo
- loop, while, for, atomic, do
- fast exceptions
- try, catch, else, finally
- nested function
- lexical closure
- accummulator
- generator
- coroutine
- type validator
- run once function
- full and safe eval
- buffered printing
- auto self
- private, public and static attributes
- read/write & read-only attributes
- class property and methods
- dynamic attribute access
- single inheritance with mixins
- multiple constructors
- super class attribute access
- finalizers
- multiple assignment
- variable and default arguments
- argument flattening
- uniform attribute access
- complex number
- big integer
- mark & sweep garbage collector