- is an open-source implementation of the AWK programming language.
Awka is not an interpreter dtke Gawk, Mawk or Nawk, but instead it converts the program to ANSI-C, then compiles this using gcc or a native C compiler to create a binary executable. This means you must have an ANSI C compiler present on your system for Awka to work.
- is an high-level dynamicly typed programming language. It can be used as an embedded scripting language. It has been designed to provide a common runtime for several different languages. Learning and using Neko is very easy. You can easily extend the language with C libraries. You can also write generators from your own language to Neko and then use the Neko Runtime to compile, run, and access existing libraries.
If you need to add a scripting language to your application, Neko provides one of the best tradeoff between simplicity, extensibility and speed.
Neko is also a good way for language designers to focus on design and reuse a fast and well-designed runtime, as well as existing libraries for accessing filesystem, network, databases, xml...
- BlackBox Component Builder
- developed by Oberon microsystems, is the component-based development environment for the programming language "Component Pascal".
Due to its stability, performance and simplicity, BlackBox is perfectly suited for science and engineering applications.
Thanks to modest hardware requirements, BlackBox can also be used in countries with limited IT infrastructure, for development, education and research.
- The COW programming language was designed with the bovine in mind. Given that cows have somewhat limited vocabulary skills, it seemed natural to incorporate only the words they know into the language. As a result, all instructions are some variation on "moo" which just so happens to be the only word they really understand.
Any other word or symbol that isn't an instruction is ignored entirely. So, spaces can be used or not. Newlines can be used or not. You get the idea. It makes commenting COW programs rather easy as long as you don't use any words that have an instruction embedded in it. All instructions are case-sensitive.
- The ideas of neural networks, fuzzy logic, and genetic algorithms are included in a mid-level computer language, FUNGAL (FUzzy logic/Neural network/Genetic Algorithm Language). This language operates on a plug-and-play network architecture based on inexpensive microprocessors, and provides for completely self-contained autonomous control of a serpentine robot. Three robots are built to exhibit individual autonomous control, semiautonomous teleoperation, and co-operation. A comparison of FUNGAL to other artificial intelligence systems is included. Finally, applications in space exploration and commercialization, deep-sea missions, nanotechnology, and np-complete software problems are discussed.
- In 2000 a.d. we started a project called "DiNGS Game Basic" DiNGS is an easy to use 2D programming language. We made a lot of progress since then, and perfected all areas, where improvements were possible. Our language grew up, and is now a professional 2d game programming kit.
Our next great accomplishment is GLBasic, which is a complete 2d/3d/networkable cross platform programming language. If you are searching for a easy to learn, fast to write, and flexible language for programming games: GLBasic is what you need.
If you don't want to learn real programming, these programs aren't for you.
If you want to compete against professional game programming companies, learn C/C++ and found your own company with at least 5 employees, you selected carefully. Good luck.
If, however, you wish to create games that have high quality on your own with little time to waste creating a game engine, a 3D framework or network components, your choice will be GLBasic.
- - Meta Language
METAL is a 100% free extended BASIC language metacompiler for Mac.
The ultimate goals of METAL are to bring back the spirit of 1980s programming and provide both beginners and advanced developers with a way to quickly convey their ideas and focus on creativity!
METAL is made by Marin Saric
- Mobile BASIC
- Mobile BASIC 2.1 allows your PC to create programs for your Java enabled Mobile Phone using our easy to learn version of the BASIC programming language. The language features integer, long, floating point and string variables, logarithm and trigonometry functions, network communications and graphics facilities. The development environment also includes integrated Map, Tile and Image editors.
Mobile BASIC 2.1 can create programs for Nokia, Sony-Ericsson, Siemens, Sharp, Motorola and Other Mobile Phones supporting Java.
- Palm Basic
- Palm Basic is a utility written for the Palm series of handheld devices. It is designed to allow you to write programs on your Palm for your Palm. The language is designed to be simple to use, yet sufficiently powerful to allow the construction of genuinely useful programs.
Palm Basic consists of a program management screen, similar to memo pad. This allows you to organise your programs by category. From here, you can edit and run your programs, or you can go into console mode. Console mode allows you to execute single lines of BASIC, or to run your programs by name.
Palm Basic supports integer, floating point, and string variables, as well as single and multi-dimensional arrays. It supports the common structures found in BASICs i.e. for - next loops, do - loop, if - else - then (either on a single line or over multiple lines), goto and gosub. It contains built-in procedures for formatted printing and inputing, basic graphic operations, as well as a full set of floating point math functions.
- Parrot is a virtual machine designed to efficiently compile and execute bytecode for interpreted languages. Parrot will be the target for the final Perl 6 compiler, and is already usable as a backend for Pugs, as well as variety of other languages.
- PocketC Architect
- PocketC Architect combines some of the best features of classic PocketC and OrbForms Designer. At its core, PocketC Architect is the advanced OrbC compiler rebuilt to run on either the desktop or the Palm itself, and enhanced to provide compatibility with classic PocketC source code. We've started this new product at v4, because it uses the same compiler and runtime as OrbForms Designer v4 will. See the new PocketC Architect section for full features and download.
- stands for Popular Assembler. It is an assembler (i.e. an assembly language compiler) designed to meet the needs of as many assembly language programmers out there as possible... This is NO easy mission, I know...
- ToonTalk 2
- ToonTalk is a completely new kind of software -- both a state-of-the-art programming language and a video game. Children create programs by performing actions in an animated world.
Computer programming can be a creative, empowering, and rewarding activity. Programs can be constructed for an incredible variety of purposes -- games, music, math, animation, simulation, science, language, robotics, education. The process of building programs entails a rich set of problem-solving skills involving analysis and design. And computer programming is a worthy subject to learn on its own merits.
But programming can be hard -- hard to learn and hard to do. Programmers usually have to learn a formal textual programming language full of difficult abstract concepts like variables, procedures, flow of control, data structures, modularity, and recursion. Some children do learn languages like Logo or Basic, especially when taught by a gifted and dedicated teacher, but most find it frustrating and boring.
ToonTalk is different. It is not only easy to learn, but fun too. It borrows heavily from video games -- appealing graphics and animation, a virtual world to explore, animated characters to interact with and get help from. Children can learn ToonTalk by playing the tutorial game, by viewing demos and tours, or by exploring with or without the help of a Martian animated coach and guide.
But ToonTalk isn't just a video game for teaching programming -- the very act of building, running, and debugging programs is like playing an adventure game. In ToonTalk, it is not only fun to play with the resulting creation, it is fun to build it.
- Whirl was designed with the following state-of-the-art features in mind:
- Ease of use
- Grilled Chicken
Unfortunately, none of those things made it into the final product.
The Whirl programming language has only two instructions: 0 and 1. While the Whirl Team was tempted to build a compiler that converted text source files of 0s and 1s into very small binary files with a sequence of 0/1 bits, the idea was thwarted at the last minute by a sudden attack of laziness. Maybe it'll happen later on when Whirl becomes adopted by the enterprise market to replace the aging Java platform.
In the world of Whirl, there are two instructions and two rings of 12 things to do on each. The instructions manipulate the rings and activate commands on the rings. The rings can also store some data within them. The rings always maintain their position and state, so nothing really resets the rings back to their default position. A Whirl programmer must always keep track of where the rings are positioned so as to not get a headache. Unfortunately, trying to track the rings' position after about 10 instructions often results in a sudden stoppage of programming due to the programmer's brain getting so dizzy it forgets how to breathe. WARNING: Programming Whirl may be hazardous to your sanity!
The Whirl environment generously gives the programmer the following tools:
- An "infinite" supply of data memory
- An ability to change the program's instruction position
- One ring of 12 Control/Logic/IO operations
- One data storage slot for the operations ring
- One ring of 12 Math functions
- One data storage slot for the math ring
- Two easy-to-remember instructions
- The FermaT Transformation System is a powerful industrial-strength program transformation system based on the WSL language.
Friday, March 03, 2006
Friday, February 24, 2006
- Zen is a full featured BASIC interpreter for the Linux operating system running on the PC. Ensure that the zen executable is placed on your path (suggest /usr/bin) and is 'chmod a+x zen'. The zenerror.inf file contains a full list of the zen error messages. This file can either be placed in '/var/zen' (which you will need to create) or in the current working directory. You may alter the text of the error messages, to another langauge for example. A small test application is included called test.zen.
The Zeno Interpreter was designed for use in the MS Windows 95 and later operating systems. The interpreter, with its built-in debugging tools, will allow you to learn good programming techniques. Included with the interpreter is an editor and an on-line language reference program. Together, these create an environment for you to learn to program in Zeno.
- Y is a stack-oriented FORTH-type programming language derived from Wouter van Oortmerssen's "FALSE".
Like FALSE, Y is cryptic to the extreme. (But it is much more powerful. Virtually all of the example programs in "Kernighan & Ritchie - Programming in C" can be done in Y in a fraction of time and code. :-) )
This stuff is provided as-is, I won't take any responsibility for damaged software, hardware, or brains. Since I'm still developing (well, something like that...), this is a very early beta version. Y looks stable and the small Y programs I tested worked fine, but this doesn't have to mean anything.
Y is what you get when you cross a programmable pocket calculator with a programming language like C. For some, Y is merely a toy. (But a very powerful one.) For others, it's just another cryptic unixlike command which probably can save you much time in special situations.
There are many good programming languages for doing large projects, but what do you use if you want a quick solution for those small but nasty everyday's problems which can't be managed with common commands? One day, I had recieved an ascii data file which must have gone through some noise-producing 7/8-Bit-gate. About twenty per cent of the characters had their highest bit set, so the text was totally corrupted. With Y, it took me less than twenty keystrokes to solve the problem by writing a binary filter. Here it is:
After all rules have been added, Yeti dumps code for a [incr Tcl] class that implements the parser. This parser uses a deterministic state machine computed from the rules. This has the advantage of using only linear runtime and memory for parsing, but the disadvantage that it is not possible to update the parser after parsing has started. It is common usage to generate a parser once at package installation time, and to store the parser in a file, from where it is then sourced.
Parsers need a scanner to their job. The purpose of a scanner is to read tokens (terminals) from an input source. A scanner generator called Ylex is included in the Yeti package; after adding rules, it also dumps code for a scanner class.
Yeti is written in Tcl. It requires Tcl 8.x, [incr Tcl] 3.x. The parser generator also requires the struct module from tcllib; this module is not needed to run generated scanners and parsers.
- X Language
- is a new multi-syntax programming including a portable set of APIs to create console or graphical applications runnable on many platforms (UNIX/X11, Win32, ...). X Language comes with an interpreter, a compiler and a debugger.
XIDEK can save you weeks or months of work. It gives you parsers, support modules, explanations, examples, organization and a framework upon which you can build.
XPL is the name of both the programming language and the compiler generator system (or TWS: translator writing system) based on the language.
- is a Basic interpreter that is:
- Open Source (LGPL)
- Cross-platform (currently Windows and Linux)
In addition to application development, WINTERP's features make it a good tool for learning about and experimenting with the capabilities of the OSF/Motif UI toolkit. Its rapid prototyping features allow UI and application designers to more easily play "what if" games with different interface styles.
Finally a scripting language which has an easy syntax (for some reason bash just doesn't work like I want it too :). If you're also one of those people, like me, who needs to look at the man pages over and over again before being able to write that simple bash script that does not give parse errors, this project is probably worth looking at.
- is intended as an easy-to-use programming, shell and script language with a syntax similar to C/C++, Pascal or Basic. vipsi can be used interactively as a shell, as a pocket calculator, for shell scripts or for CGI scripts.
- - The UFO Project - The United Functions and Objects project has developed a programming language which unites functional and Object Oriented Programming techniques. A large subset of UFO is a pure functional language incorporating the OO notions of classes, inheritance, and dynamic binding. However, UFO as a whole is not a pure functional language. It has stateful objects, which allow programs to be written in a concurrent object-oriented style where appropriate. Safeguards are provided, both in the semantics of operations on stateful objects and in the type system, to minimise the problems associated with introducing state.
Unicon is a superset of Icon with "looser slots and a higher payback" to use Las Vegas terminology. It adds objects, networking and file systems access, execution monitoring and visualization, and an ODBC database interface that operates on local files or across a network with SQL database servers. It is portable to (minimally) Linux, MS Windows, IRIX and Solaris environments. Part or all of Unicon will port readily to other Icon 9.4 platforms.
- is a mixed BrainF**k/Forth metaphor: A Toadskin program is the definition of a word using built-in words and words defined using built-in words. Words may be one character in length. Oh. And watch out, the argument stack is a ring buffer, but the function stack isn't. The built-in words are mostly BrainF**k syntax where appropriate.
It features simple (trivial) usage of every class. This library was written from API side, and then implemented in C++.
Command line and config file handling is very customizable: there is a possibility of setting up various special properties such as quoting characters, deliminator strings, file comment prefixes and others. It supports several common data types such as booleans, long and string.
Socket communication classes are very intuitive and easy to use.
Strings and buffers classes makes usage of strings and buffers just trivial.
The TPT interpreter runs in one pass, avoiding expensive compilation. The language relies on C++ streams for I/O, making TPT more easily portable, small, and fast. There are no bulky modules to include. TPT does not execute as a program or script. It instead translates templates to text, and relies on the C++ program to decide what to do with the text.
What is TPT used for? At this time, TPT is used for generating CGI web pages, C and C++ source code, Make files, and e-mail messages.
The inspiration was mainly Clarion template language with beautiful "embed/emit" commands. This feature actually mimics human activity during code writing: author (programmer - alive code generator) never writes text linearly, he rather moves over files inserting pieces of code here and there.
With Turbo/PL's short learning curve and high performance, beginners and professional developers alike can create powerful, full-featured Windows software-applications without previous experience with the language.
- - Generic shell script compiler. shc creates a stripped binary executable version of the script specified with -f on the command line. shc itself is not a compiler such as cc, it rather encodes and encrypts a shell script and generates C source code with the added expiration capability. It then uses the system compiler to compile a stripped binary which behaves exactly like the original script. Upon execution, the compiled binary will decrypt and execute the code with the shell -c option. Unfortunatelly, it will not give you any speed improvement as a real C program would.
In order to facilitate the compilation to efficiently executable code, certain functional language features which are not considered essential for numerical applications, e.g. higher-order functions, polymorphism, or lazy evaluation, are not (yet) supported by SAC. These may be found in general-purpose functional languages, e.g. Haskell, Clean, Miranda, or ML.
In order to overcome the acceptance problems encountered by other functional or array based languages intended for numerical / array intensive applications, e.g. Sisal, Nesl, Nial, APL, J, or K, particular regard is paid to ease the transition from a C / Fortran like programming environment to SAC.
In addition, SISC is a complete implementation of the language. The entire R5RS Scheme standard is supported, no exceptions. This includes a full number tower including complex number support, arbitrary precision integers and floating point numbers, as well as hygenic R5RS macros, proper tail recursion, and first-class continuations (not just the escaping continuations as in many limited Scheme systems). SISC also attempts to implement the standard as correctly as possible , while still providing exceptional performance .
This is a free port of the original SIL (SNOBOL4 Implementation Language) "macro" version of SNOBOL4 (developed at Bell Labs) with the `C' language as a target.
SNOBOL4, while known primarily as a string language excels at any task involving symbolic manipulations. It provides run time typing, garbage collection, user data types, on the fly compilation. It's primary weakness is it's simple syntax, and lack of "structured programming" and "object oriented" constructs.
However some consider the spareness of SNOBOL4 syntax a strength when compared to some "modern" agglomerations such as Perl.
The latest release can be found at http://www.snobol4.org
SR has been used at a number of universities and labs for course work and research projects involving concurrent programming. It has been used in concurrent programming courses to reinforce concepts with small programming projects and with larger projects such as experiments with parallel algorithms, replicated databases, distributed simulations, and parts of distributed operating systems such as file systems and command interpreters. SR has also been used as a tool in several masters theses and doctoral dissertations to conduct experiments in parallel and distributed programming and to implement larger systems such as a system for mixed language programming, one for distributed implementation of graph algorithms, experiments with load balancing algorithms, and experiments with upcall program structures.
SR is the predecessor to the MPD programming language, which provides the same capabilities using the syntax described in Foundations of Multithreaded, Parallel, and Distributed Programming.
STOICAL is vastly different from its predecessors. Primarily because so much has changed since the decades ago that they were developed. Today STOICAL is powerful and general enough to be used as a high performance replacement for semi-compiled and interpreted languages like Perl, Python, SED and Awk. And because of STOICAL's advanced support for networking and concurrent threads of execution, it can be used to write efficient long-running servers and daemons that would normally need to be written in C. The intent here is not to explore the intricacies of archaic systems, but to create a new and modern language, well suited to the world as it exists today. STOICAL might therefore be more accurately represented by the recursive acronym SINS, SINS Is Not STOIC, but this word has a remarkable stigma attached to it ;-)
ScriptBasic implements a rich set of instructions that are available under Win32 as well as under Linux/UNIX. Programs written in ScriptBasic are portable unless you work hard to insert some system specific code.
If you miss some functions in the language itself there are external modules that implement several features, like CGI handling, MySQL access, regular expressions, graphical user interface, NT/UNIX specific functions (in case you really need something system dependant) and several others.
If you need some more that is not currently available you can ask for it on the ScriptBasic mailing list or you can easily write your own modules in C. ScriptBasic internals, source code and interfaces are well documented. To get a jump start you can even listen to audio/slide show tutorials. Subscribe to the mailing list now!
ScriptBasic is fast, it generates a compact internal code, which is interpreted. This internal code occupies a single, continuous memory chunk and is usually saved into a cache file. The cache file is automatically checked by ScriptBasic and thus it compiles the source only when needed.
You can also save this code into separate file and deliver it as your application without giving out your source code. This is to protect your intellectual property if you wish to use it. What is more ScriptBasic can be compiled to C and this way you can generate standalone executable on UNIX as well as on Win32 operating systems free of charge.
To program web application you can use ScriptBasic as a CGI interpreter, but there is even a better way. ScriptBasic is integrated into a standalone webserver that executes ScriptBasic programs in a single process without the CGI overhead lighting fast. Under Windows NT you can install this web server as an NT service and use it several ways. This application named Eszter SB Application Engine is supported by the CGI and the MT module allowing you to use in-memory application and session variables without file read/write overhead.
It is close in spirit and semantics to Smalltalk:
- It is a pure object-oriented language, i.e., everything in the computational domain of Self is an object.
- Its syntax borrows heavily from Smalltalk.
- As in Smalltalk, variables are of unrestricted type.
- It uses blocks - objects which behave like procedures - to implement control structures.
- Programs are constructed incrementally within the programming environment. An exploratory style is encouraged.
- Self is considerably simpler than Smalltalk in syntax and semantics.
- More of the basic facilities in the Self system are implemented in
- Self has no classes. Instead a more direct object-based inheritance
mechanism is provided. The programming environment facilitates direct
manipulation, in which the programmer communicates with objects directly (or appears to), rather than applying "tools" to effect changes.
It's unique programming language capabilities make it the ideal general-purpose language for application development, ensuring high programmer productivity. SheerPower 4GL is easy to learn. Most programmers are writing SheerPower 4GL applications within a few hours.
SheerPower is a full development language, but shares many advantages with scripting languages -- such as ultra-fast development speeds and ease of learning the language. SheerPower can be used to write programs of any size, from simple-input programs to vast database applications. SheerPower may look somewhat similar to that of a structured BASIC language, but SheerPower is beyond BASIC!
It can be used by experienced developers to write and test on the fly small routines, and is a good solution for educational purposes.
Do not use it in production environments or to manage large projects.
based on semantic extensions to Smalltalk-80 while retaining the
human-friendly syntax. Slate is primarily based on the choices of
combining the flexibility of object-specific behavior and expressiveness
of multi-method dispatch into one coherent form. The environment heavily
borrows many good ideas from other systems, focusing on integration of
things long experimental into one coherent whole.
Slate is intended to be useful in every role that Squeak and Self are,
and to push the boundaries farther in the areas of dynamic media and
interactivity and flexibility. These will take time to demonstrate, as
the environment is currently still based on console interaction, but the
framework is already in place for forward progress.
SmallBASIC IS NOT A DEVELOPER TOOL FOR PROFESSIONAL PROGRAMMERS. Please don't ask us to turn it into one. We value the simplicity of a console more than the beauty of a performance-hogging GUI.
- is a free programming language based on REBOL.
There's also a demo page, which allows you to type in ruri-language code and have the appropriate IJVM or IJVMA output produced.
- is a powerful and extensible scripting language with advanced symbolic processing and functional programming capabilities. Q is based on term rewriting. Consequently, Q scripts are just collections of equations which are used to evaluate expressions in a symbolic fashion. Despite its conceptual simplicity, Q is a full-featured functional programming language with a modern syntax, curried function applications, dynamic object-oriented typing, exception handling, and POSIX multithreading. Scripts are executed in a bytecode interpreter which byte-compiles scripts in an eye blink and runs them about as fast as interpreted Lisp or Haskell. The interpreter provides a built-in symbolic debugger which allows you to trace the reductions performed during expression evaluation. Q also has a libtool-based Q->C interface which makes it easy to extend the interpreter with your own primitives written in C. Conversely, the new C->Q interface (added in Q 5.0) allows you to embed the interpreter in your C/C++ applications.
Wednesday, February 22, 2006
is a programming language designed to combine the simplicity of scripting languages like PHP and Perl with the power and speed of C++ and Python.
is an interpreter of 4 object-oriented scripting languages:
- Cross-language integration. For example, you can use modules written in paxBasic and paxC in your paxPascal scripts and vice versa.
- Separate compilation of the modules.
- Direct calling dll-defined routines. All calling conventions register, pascal, cdecl, stdcall, safecall are supported. (See demo.)
- Embedding scripts into html pages.
TPaxScripter component allows to embed paxScript interpreter into your Delphi or Borland C++ Builder application, so you can extend and customize the application without having to recompile it.
Using TPaxScripter you can
- Import Delphi classes, routines, constants, and variables.
- Import Delphi units automatically with paxScript Importer.
- Convert dfm-files into the paxPascal scripts.
- Call script-defined functions.
- Save/Load compiled scripts to/from a stream.
- Unite source code modules and compiled (binary) modules in your script project.
- Build the code explorer tree.
- Customize compilation process and error handling.
- Use scripter in the debugger mode (breakpoints, step into, trace over, run to cursor). The component comes with full source code of paxScript IDE, so you can use it as a base to develop your own integrated environment.
TPaxScripter component is thread safe. It has small footprint (about 30-40 Kb per extra TPaxScripter instance).
A polymorph functional language to embed in applications
PILL is a scripting language for applications. The syntax (based on functional languages) might look weird but it have some advantages (and i like it).
It contains only a minimal set of functions, applications will have to register new ones via the interpreter's API in order to make it to replay the scripts as wanted.
This abstraction offers a flexible way to expand scripts abilities to virtually any domain and to allow various applications to share/re-use foreign scripts.
is a SWIG extension that allows new language modules to be programmed in Python. It's mostly a SWIG wrapper for SWIG itself ;-)
(pipe) is a universal filter application. It uses plugins to transmit and convert data. They can be nested, so the inner structures can become quite complex (non-linear). The command-line interface is similar to a programming language and very easy.
The Private COMpiler builds a .COM, .EXE or .ASM file from a given source file.
Features: Easy to understand programming language, even for those who aren't familiar with assembler, c, Pascal or any other 2nd or 3rd generation language. You can use variables on some important commands.The length of the variable name isn't important and it's case insensitive.
You can protect your executables using encryption or/and with anti-hacker code.
You can predefine your compiler arguments using a PCOM.CFG configurationfile.
You can compress the executable right away, so it's as small as possible.
And finally, PCOM-executables support long filenames.
- Development Assistant for PL/M (DA-PL/M) offers new possibilities of development and maintenance of PL/M applications. This program is completely project oriented and it is very easy to handle both, small and large projects.
is a simple, powerful way to add custom scripting to any program. A basic C parser and interpreter is included, and new scripting languages can be designed easily.
Setup of new commands and languages requires only minor programming changes. The C language module with full source code is included in the freeware release, to serve as an example for new languages.
The PLC library is available as freeware, and the complete source code to PLC Pro may be licensed for a nominal fee.
- A free open source version of the (commercial but very cheap and highly recommended) Euphoria programming language running on the Parrot virtual machine (which is also open source and free).
- A simple, easy to learn, fast, lightweight, interpreted and/or compiled, cross-platform, open source, and several other buzzwords, programming language, with a searchable library of over 1,200 user contributions freely available. A bad pun on Pete+Lomax+Euphoria+Parrot.
is a pascal interpreter with syntax highlighted editor and templates. Ideal for use at home or at school to learn programming. Help file included.
is a visual programming tool designed for a simple and fast generation of the programs for Windows 95/98/NT/ME/2000/XP. Its principal characteristic is the graphical presentation of the program structure. The program sections are assembled using the mouse like a jigsaw puzzle. Thanks to the justification check of the element combinations, carried out already at the time of the program generation, there is no chance of syntactic failure origination. The program presentation by means of a tree structure enables a considerable improvement of the program lucidity. The creation of the program is quickly becoming extraordinary easy and flexible.
Peter is intended for a broad range of the users. By using it, even the children of the pre-school age are able to draw pictures and teach their little rabbit to move. On the other hand, there are a lot of powerful functions intended to use by skilled programmers. It is not Peter's goal to train programmers out of all users. Its objective is to make the program generation accesible to all who want to create. No knowledge in the programming or computer areas is necessary. Everything is covered by the numberless functions. This is an effective mean for training the logical thinking, imagination, and aesthetic feeling.
is a small, pure language for building applications from software components. Piccola is small in the sense that its syntax is tiny, and it is pure in the sense that it provides only compositional features -- computation is performed entirely by components of the host programming language.
is a tiny but expressive programming language that was especially designed to teach advance computer science concepts to students in other sciences than computer science (such as Physics and Chemistry). In a sense, Pico can be seen as a non-trivial marriage between the power of languages like Scheme, and, the standard infix notation students are used to from ordinary calculus. A.o., Pico features garbage collected tables (i.e. arrays), higher order functions, objects, meta programming and reflection. But above all, Pico is small! Really small!
is a language in the ML tradition, formed by adding a layer of convenient syntactic sugar and a static type system to a tiny core. The current release includes a Pict-to-C compiler, reference manual, language tutorial, numerous libraries, and example programs.The core language - an asynchronous variant of Milner, Parrow, and Walker's pi-calculus - has been used as a theoretical foundation for a broad class of concurrent computations. The goal in Pict is to identify high-level idioms that arise naturally when these primitives are used to build working programs - idioms such as basic data structures, protocols for returning results, higher-order programming, selective communication, and concurrent objects. The type system integrates a number of features found in recent work on theoretical foundations for typed object-oriented languages: higher-order polymorphism, simple recursive types, subtyping, and a powerful partial type inference algorithm.
The Pizza language is an extension to Java with three new features:
- Generics (aka Parametric polymorphism)
- Function pointers (aka First-class functions)
- Class cases and pattern matching (aka Algebraic types)
Furthermore you can use the Pizza compiler embedded into other applications.
is a new programming language. It utilizes powerfull static typing techniques. It was designed to fix some frustrations that people were having with c++ java and c#. It is bsd licensed and free for both opensource and commercial use.
- , the Popular Assembler Project - is an assembler (i.e. an assembly language compiler) designed to meet the needs of all assembly language programmers out there... This is NO easy mission, I know...
is a new dynamic object-oriented language that improves upon the excellent language Python. While not compatible with Python, Prothon is close enough for Python code to be easily ported to Prothon.
Prothon is built upon the more flexible foundation of Prototypes rather than the classes of Python, while still fully supporting classes. This allows other object paradigms than classes to be used like acquisition and maybe even aspects.
is a visual dataflow programming environment for interactive multimedia, similar to Max and jMax.
Friday, February 17, 2006
is a simple and safe object-oriented language created by N.Wirth, the author of Pascal and Modula2. It is statically strongly typed and has garbage collection. Most of good ideas incorporated in design of Java were in Oberon2 long before. OOC is an open source project to produce a family of optimizing Oberon2 compilers. The compiler with an ANSI C back-end, oo2c, is quite mature, and provides a complete and convenient Oberon2 development environment. It comes with a rather comprehensive standard library, Code Navigator, and an Emacs mode. It is easy to call C functions and libraries from Oberon2.
is a general purpose object-oriented programming language. It is designed to be simple to learn, easy to use, yet still powerful, combining the convenience of an interactive interpreter with many of the features of Java:
- a simple java-like syntax
- class system, with single inheritance and mixins
- private/protected/public fields and methods
- exceptions for error handling
- synchronization and threading
- compiles to bytecode for higher performance
- osdoc: a javadoc-like tool to extract API documentsfrom src code, plus API docs accessible reflectively
- XML-RPC support
- Windows COM support
- regular expressions (requires java v1.4 or later)
is a powerful stack-based, multi-threaded, interpreted, general purpose programming language similar to PostScript. It can be embedded as an extension language similarly to ficl (Forth), guile (scheme), librep (lisp dialect), s-lang, Lua, and Tcl.
is a highly portable and free implementation of the Comal programming language written by moi. Currently supported platforms are Unix, MsDos and Win32 (95, 98, NT, 2000, XP and whatever they come up with next :-)
Comal is a crossover between Basic and Pascal, with the best features of both and none of the drawbacks of either.
is an openly available specification of the Spice language - a modern programming language with some nice XML processing features. It is designed with the needs of part-time or occasional programmers in mind. The language features are properly separated and their corner cases have been eliminated. This design means that if you only use Spice occasionally, you're likely to find it easy to come back to despite the breaks.
is an interpreted dynamic parser which is well suited to rapid development of parsing solutions, starting from rapid language prototyping to full fledged compilers.
OpenZz is a dynamic LALR(1) parser which allows its grammar to be modified and extended by commands written in its own language as well as through functionality provided by external libraries. OpenZz is implemented as a C library and exports C-bindings, so it can be joined with other code libraries both by static linking and runtime module loading.
Zz is a very sparse language: few operations are intrinsically supported. The key of Zz is the syntax extension statement. In the current release the following are available as predefined statements: assignment, print, evaluation of simple expressions, and a limited number of other basic instructions. In principle there is no need of Zz instructions, except for only the syntax extension capability. The intrinsic Zz statements are however useful for purposes of exercise and in the early stages of application development.
Ox is an object-oriented matrix language with a comprehensive mathematical and statistical function library. Matrices can be used directly in expressions, for example to multiply two matrices, or to invert a matrix. Use of the object oriented features is optional, but facilitates code re-use. The syntax of Ox is similar to the C, C++ and Java languages. This similarity is most clear in syntax items such as loops, functions, arrays and classes.
- This software performs an original script language. Little batch processing etc. can be created easily. It operates by the console.C-language-like syntax.
- Modification nScript by Tomoaki Nakashima.
is a traditional scripting environment for the Apple Macintosh. The shell is available in two forms. A light version, called nShell(tm), is freely distributable for non-commercial purposes. A second version, called nShell-Pro(tm), [was] available as a commercial product [link is now to pro version source]. Our goal is to make the shell environment available to as many users as possible, while providing serious users with the support and reliability of a full commercial product.
is a portable/multi-platform, lightweight TCP/UDP socket scripting system. It is intended to automate situations, built on a word-to-word ruleset response system. It includes wildcard support, character replacement, random replacement, argument inclusion, server timeout, initial send, display altering, multiple character dump formats, telnet protocol support, logging, program to socket dumping, executable ruleset support, reverse binding, module support, data truncation, data formatting, permission options, virtual hosting support, history storage, dynamic storage variables, directory placement, character omitting, timed rules, background support, syslog support, routing support, socket options, interactive mode, and graphical user interface support.
stands for Natural Language Processing Toolkit, and is part of the Traduki project. NLTPK is written in C and Lua programming languages and is released under the GNU Library General Public License: in short, it allows you to use it for free, even in commercial products, without having to release the code of your program (but you have to make public changes to the library).
Despite still in alpha stage, NLPTK can be used in many different kinds of software, like machine translation, text analysis, spam filters, adventure games, etc
- Nullsoft Scriptable Install System - is a tool that allows programmers to create such installers for Windows. It is released under an open source license and is completely free for any use.
An installer is the first experience of a user with your application. Slow or unsuccesful software installations are the most irritating computer problems. A quick and user friendly installer is therefore an essential part of your software product.
(Not another scripting language) is a small, simple, yet full-featured language designed as extension language in situations where larger languages are simply to large or unwieldy to embed. It supports OOP syntax and functional programming, works on the traditional data realm of strings, vectors, and hashes, and does it all in less than 100k of ANSI C. Please note that this is not the NASL extension language from the Nessus project.
is a new programming language. It extends the ideas behind object-orientation in order to better support modular programming and static type safety. It also incorporates features from functional programming, and puts into practice state-of-the-art results from academic research. This results in more expressivity, modularity and safety.
is a programming language based prototyping environment with powerful programming and scripting capabilities. Nickle supports a variety of datatypes, especially arbitrary precision numbers. The programming language vaguely resembles C. Some things in C which do not translate easily are different, some design choices have been made differently, and a very few features are simply missing.
Nickle provides the functionality of UNIX bc, dc and expr in much-improved form. It is also an ideal environment for prototyping complex algorithms. Nickle's scripting capabilities make it a nice replacement for spreadsheets in some applications, and its numeric features nicely complement the limited numeric functionality of text-oriented languages such as AWK and PERL.
is an Object-Oriented language, with a syntax similar to Java or C++, and with advanced high level features such as a strong type system, automatic memory management, and global code optimisation.
is a small macro-style tool for maintaining small (or not small) configuration files that tend to change frequently or are deployment specific. An unholy marriage of make, m4, perl and lisp useful for "hands-off" configuration and build environments.
is a light-weight, cross platform programming language. It is garbage collected and self hosting and produces portable byte-compiled binaries that can be executed on any platform with the appropriate interpreter. Interpreters are available for Linux, DOS (32-bit) and DOS (16-bit) and the interpreter source should be easily compilable for other platforms.
Back in 1997 I decided, more or less for the hell of it, to design and implement a programming system. Mercat, nee Micron, is that language, and this is it.
Mercat is not really useful for anything much. It is, on the other hand, an excellent example of how to implement a self-hosted recursive-descent-parsed language and virtual machine. The code is --- I hope --- reasonably easy to understand, and I think the overall design is quite elegant.
- Garbage collection
- Portable binary files
- C-like syntax
- Associative arrays as a primitive type
- Real strings
- Easily expandable through a simple, fast system call interface
- Self-hosted the compiler and assembler are written in Mercat
- Text screen interface through ncurses
is a new programming language that was developed for applications distributed on a small scale. You can make simple applications. Features include: if statements, nested functions, forms, and over 100 functions. To run Mocha you'll need the Visual Basic 6.0 runtime file (msvbvm60.dll), the Microsoft Common Dialog Control, and the Windows Common Controls. For the actual Mocha applications though, you only need msvbvm60.dll.
MPD is a new programming language that has a syntax very close to the one used in the book Foundations of Multithreaded, Parallel, and Distributed Programming. The name of the language comes from the first three letters of the main words of the title of the book: Multithreaded, Parallel, and Distributed. These words also capture a distinguishing aspect of the language, namely that it supports all three of these concurrent programming techniques.
MPD is implemented as a variant of the SR programming language. It has a different parser, but it uses the same intermediate form and run-time system as SR. Consequently, MPD provides the same variety of concurrent programming mechanisms as does SR.
The language overview page contains links to a tutorial on the language, sample programs, a synopsis of the syntax of MPD, and a description of how to compile and execute programs. The MPD distribution contains manual pages and numerous additional examples.
MPD programs can execute on single processors, shared-memory multiprocessors, or clusters of (homogeneous) processors. The implementation supports a variety of different kinds of processors and Unix systems. See the download page for further information.
is a command line utility that can make using Windows a much less annoying experience by allowing you to start programs simply by typing their command lines, instead of wading through dozens of menus.
This is great for fast typists, people who are used to UNIX, and generally anyone who doesn't like the idiot-proof way Windows tends to do things.
MCL is highly customizable, widely extensible, very powerful, and convenient. It was written using Microsoft Visual C++ 6.0, and contains nearly 6000 lines of C++ code. Because it does not make use of MFC, Delphi, or Visual Basic runtime code, memory usage is low, download size is small, and performance is high.
is a simple typeless language which is based on BCPL. It makes extensive use of pattern matching somewhat related to that used in ML and Prolog, and some other features come from C.
An interpretive implementation of MCPL has been developed in a style similar to the BCPL Cintcode implementation. It currently works well enough to run several demonstration programs. Experimental native code versions for Linux and the DEC Alpha are included as part of this distribution.
stands for MIX Development Kit, and provides tools for developingand executing, in a MIX virtual machine, MIXAL programs.
The MIX is Donald Knuth's mythical computer, described in the firstvolume of The Art of Computer Programming, which is programmed usingMIXAL, the MIX assembly language.
MDK includes a MIXAL assembler (mixasm) and a MIX virtual machine(mixvm) with a command line interface. In addition, a GTK+ GUI tomixvm, called gmixvm, is provided and, in case you are an Emacs guy,you can try misc/mixvm.el, which allows running mixvm inside an EmacsGUD buffer.
Using these interfaces, you can debug your MIXAL programs at sourcecode level, and read/modify the contents of all the components of theMIX computer (including block devices, which are simultated using thefile system).
- Meta Language
METAL is a 100% free extended BASIC language metacompiler for Mac.
The ultimate goals of METAL are to bring back the spirit of 1980s programming and provide both beginners and advanced developers
ist ein Programm für alle Windows (32-Bit) Systeme mit dem Sie Ihre Arbeit am PC automatisieren können, d.h. Aufgaben die Sie bis her immer von Hand mit der Maus oder Tastatur gemacht haben können Sie jetzt von MacroX erledigen lassen, einfach und schnell!
Maude is a high-performance reflective language and system supporting both equational and rewriting logic specification and programming for a wide range of applications. Maude has been influenced in important ways by the OBJ3 language, which can be regarded as an equational logic sublanguage. Besides supporting equational specification and programming, Maude also supports rewriting logic computation.
Rewriting logic is a logic of concurrent change that can naturally deal with state and with concurrent computations. It has good properties as a general semantic framework for giving executable semantics to a wide range of languages and models of concurrency. In particular, it supports very well concurrent object-oriented computation. The same reasons making rewriting logic a good semantic framework make it also a good logical framework, that is, a metalogic in which many other logics can be naturally represented and executed.
Maude supports in a systematic and efficient way logical reflection. This makes Maude remarkably extensible and powerful, supports an extensible algebra of module composition operations, and allows many advanced metaprogramming and metalanguage applications. Indeed, some of the most interesting applications of Maude are metalanguage applications, in which Maude is used to create executable environments for different logics, theorem provers, languages, and models of computation.
is a simple, object-oriented and strongly typed language.
- 'Misc Is a Script Compiler' - is a programming language designed especially for performing calculations on large amounts of data. The Misc Engine library is a portable C++ library containing Misc compiler, interpreter and standard built-in functions.
The main purpose of Misc is to serve as a base engine for other applications. For example, one could create a GUI front-end for drawing graphs using the data generated by a script written in the Misc language. The functionality of the Misc Engine by itself is limited to calculations, data manipulations and simple I/O operations. However its ability to be extended with additional functions makes it a powerful tool.
- Misc is a high level, procedural language. It's syntax is similar to C,but like most other scripting languages, it supports dynamic variable types.
- Native data types include booleans, integer, floating point and complex numbers, vectors and matrices up to 4x4 elements and strings.
- Misc can efficiently perform operations on large data using continuous arrays and lambda functions.
- Misc is able to operate on complicated, hierarchical data structures.
- A large number of built-in functions is included in the Misc Standard Module.Additional modules can be easilly created and plugged into Misc Engine.
is a non-strict functional language specifically designed for an OO envrionment. It can be thought of as a 'light' version of Haskell with the syntax a meld of that of Haskell and the Java/C family.
is a programming language and development environment for the Apple Macintosh, written and maintained by Mike Hore . It is an object-oriented native-code dialect of the Forth programming language, with origins as a re-implementation of Neon .(Neon is a commercial programming package for the Macintosh that was sold by Kriya Systems, Inc. in the mid-1980s.)
While Neon died off years ago, Mops has thrived and continued to continued to improve, earning a reputation along the way as being both agile and user-friendly. Uniquely, Mops has included its complete source code in each distribution since its first public release. Seventeen years since its inception, Mops has completed its transition into a native stand-alone development solution for Mac OS X, with its original author still at the helm.
As a fine example of public domain software, Mops attracts advanced and novice users alike. Whether you have become frustrated with traditional vendor-supported language "solutions", grown resentful of the legal restrictions imposed on you by most developers of commercial software, or even if you never thought you had a reason (before now) to try something different, Mops might be just what you are looking for!
- My Business Basic - is an open source Business Basic Interpreter/Run-time environment. We are working towards becoming a free, fully functional business basic.
is a HTML precompiler for static home page generation. It detects special HTML tags in your page and generates HTML code out of it.
- 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
- customizeable init system
- user tag definitions
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
(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.
-- while not yet a hardware description language, may be seen as the first step in that direction.
- 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
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.
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.
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.
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.
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.
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.