Transmuter Programming Language 0.9.2

Transmuter Programming Language is an extremely dynamic, biologically-inspired prototyping language providing a framework for experimenting with naturally evolving systems of objects over the net, and for exploring new ideas about recombinant software, code morphing, and evolutionary programming.
Trans is also a very capable general-purpose programming language. Its fast, flexible, compact, object-oriented, highly extensible, and easy-to-learn. It can be used for rapid prototyping, or as a scripting language, an embedded language, a network server or client, a system of cooperating network nodes, a real-time control and monitoring system, and more.
Trans is not only typeless, but also classless. Instead of defining static classes, existing objects serve as prototypes for new objects. New objects are then extended or modified as desired. This modification can occur both statically at compile-time, or dynamically at run-time. Unlike most earlier prototyping languages, Trans uses a concatenation-based prototype system, with no pointers to parent object chains. Parent objects are simply copied into the new object being constructed, allowing for much faster references to inherited members and better object encapsulation. Inheritance is fine-grained, implemented at the member level rather than the object level.
Objects can be saved and loaded externally either as Trans source code, or in bytecode format in network byte-order (as in Java). All Trans source code is compiled to an internal bytecode representation before execution. Since the Trans compiler and interpreter are completely integrated, the compiler is directly accessible to the interpreter at run-time, and the interpreter is also directly accessible to the compiler at compile-time, allowing for complex macro constructs and expressions. Trans uses a fast single-pass compiler, allowing source code to be passed over the net to any Trans instance or server, with little impact in performance.
Trans includes support for integers, floating point numbers, ANSI and Unicode (UTF-16) strings, many builtin functions (including File I/O and TCP/IP Sockets), user-defined functions, and native functions. All functions are atomic objects, and can be passed around and manipulated like any other data item. Builtin functions are treated like user-defined functions, and must be defined before they are used. Native functions located in already-compiled external libraries can also be defined, called, and manipulated like any other data item, with type conversions handled automatically by Trans. And since Trans is implemented as a runtime library with an external API, it can also be embedded in other software environments, such as Java.
Trans also includes a rich assortment of operators, expressions, and statements. Many of these will be familiar to C and Java programmers, but there are significant additions, enhancements, and contextual differences. There are also several important modifiers controlling the disposition of members within an object at compile-time and run-time. A powerful regular expression engine similar to the engines found in Perl, Python, and other languages is also provided. Multiple threads are supported via a simple deterministic threading model.
Trans is relatively lightweight, designed to consume minimal resources such CPU, memory, disk, bandwidth, etc - an important feature in performance-critical real-time environments. The compiler and interpreter are written in C++ and integrated into one library module, using only standard C libraries and Berkeley v1.1 sockets, with no other dependencies. As much as possible, Trans is designed to be operating system and hardware independent, and is currently implemented on the Win32 and x86 Linux operating systems.
The design of Trans was influenced by many other languages, including C/C++, Java, JavaScript, Lisp, Self, Python, Ruby, Perl, and others.
Enhancements:
- This substantial release includes a new x86 Linux version, many language and built-in function enhancements, new optional syntaxes, true aliases, enhanced macro code generation/construction, restructured and restyled import objects and shell, library objects, more detailed examples, a new external API, and increased stability and speed.