Friday, February 24, 2006

S is for ...

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

is a multi-platform programmer's library designed to allow a developer to create robust multi-platform software. It provides facilities required by interactive applications such as display/screen management, keyboard input, keymaps, and so on. The most exciting feature of the library is the slang interpreter that may be easily embedded into a program to make it extensible.

(Single Assignment C) is a strict purely functional programming language whose design is focussed on the needs of numerical applications. Particular emphasis is laid on efficient support for array processing. Efficiency concerns are essentially twofold. On the one hand, efficiency in program development is to be improved by the opportunity to specify array operations on a high level of abstraction. On the other hand, efficiency in program execution, i.e. the runtime performance of programs both in time and memory consumption, is still to be achieved by sophisticated compilation schemes. Only as far as the latter succeeds, the high-level style of specifications can actually be called useful.

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.

- To develop a simple scripting language engine (SIL) to run under MS-DOS console, Win32, and Linux console.

(Second Interpreter of Scheme Code) is an extensible Java based interpreter of the algorithmic language Scheme. SISC uses modern interpretation techniques, and handily outperforms all existing JVM interpreters (often by more than an order of magnitude).

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 .

- Machine Independant SMAL assembler and linker supports conditional and macro assembly and all linkage editing operations commonly associated with languages such as FORTRAN and C. It comes with a user's manual that also explains how to customize it to support a variety of machine instruction sets.

is a Turing-Complete assembly-like language with no jumps.

- 1.0 release of ``The Macro Implementation of SNOBOL4 in C'' (CSNOBOL4)

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

- A simple interpreter of a pseudo assembler language. A command line interface (dos and later *nix) and a win32 gui interface are available.

is a language that helps you do exploratory programming. It was developed to test the idea that visual programming, logic programming, and programming with sets (with partitioning constraints) are highly complementary approaches to programming that when combined produce a good language for exploratory programming. The implementation of SPARCL is only an academic research version: it demonstrates of some of the possibilities of the SPARCL approach. The user environment for the two dimensional representation is fairly complete and is reasonably performant, so you can get an idea of what it's like to build and "read" SPARCL programs. Its most notable drawback is that the interpretation of SPARCL programs is very slow. Also, the three-dimensional representation implementation is rudimentary.

SPARK stands for the Scanning, Parsing, and Rewriting Kit. It formerly had no name, and was referred to as the "little language framework." The first version (circa 1998) was described in the paper Compiling Little Languages in Python at the 7th International Python Conference.

(Synchronizing Resources) is a language for writing concurrent programs. The main language constructs are resources and operations. Resources encapsulate processes and variables they share; operations provide the primary mechanism for process interaction. SR provides a novel integration of the mechanisms for invoking and servicing operations. Consequently, all of local and remote procedure call, rendezvous, message passing, dynamic process creation, multicast, and semaphores are supported. SR also supports shared global variables and operations.

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.

was inspired by the classic stack language STOIC. STOIC was developed circa 1977 by Jonathan M. Sachs while at the Biomedical Engineering Center for Clinical Instrumentation under the Massachusetts Institute of Technology Program in Health Sciences and Technology. STOIC was itself preceded by a language called FORTH, developed circa '68 for the National Radio Astronomy Observatory in Charlottesville Virginia by Charles H. Moore. Moore, though clinically insane, has continued to extend his language over the years. At the time of this writing FORTH is known to him as colorForth; One imagines that these colors are much like those present in his twisted visions and terror filled dreams. Sachs, however, is now dabbling in software for the Pocket PC architecture, and appears to have all but forgotten about STOIC. At one point in the early '80s, a fellow named Ernest E. Bergmann attempted to reincarnate STOIC in a language dubbed PISTOL (Portably Implemented STack Oriented Language). This implementation had its roots in BDS C, and remains something of an amusement.

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

is a modern multi-paradigm programming language designed to express common programming patterns in a concise, elegant, and type-safe way. It smoothly integrates features of object-oriented and functional languages.

This is a free BASIC interpreter. Is it just another after the so many costly and free interpreters? Well, you can decide, here it goes:

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.

is a free multipurpose C-like scripting library. The idea was to make a script engine for any purpose you would need. This can be for AI in the game, for macros in an editor or whatever. This is for things you cannot (or don't want to) have compiled (hard-coded) inside your program.

Self is an object-oriented programming language and associated
programming environment.

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.

However, it differs from Smalltalk in several important respects. The principal force guiding the design of Self was the desire for simplicity and concreteness. This force is manifested thus:
  • Self is considerably simpler than Smalltalk in syntax and semantics.

  • More of the basic facilities in the Self system are implemented in
    Self, itself.

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

- The Shakespeare Programming Language - The design goal was to make a language with beautiful source code that resembled Shakespeare plays. There are no fancy data or control structures, just basic arithmetic and gotos. You could say we have combined the expressiveness of BASIC with the user-friendliness of assembly language.

SheerPower 4GL
SheerPower 4GL is the Next Generation Programming Language for Windows. Novices, hobbyists and professionals all benefit from using SheerPower 4GL!

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!

CodeWorks Inc. introduces SiMPLE, a new beginner-friendly programming language for kids (and adults) who are looking for a new way to have fun with their computers. (SiMPLE currently works only under Windows)

(Simplicity itself generates interesting languages...) is an interpretted (sic), object-oriented programming language. It features a LISP-like syntax, a Self-like object model, garbage collection, exceptions, continuations, lexical scoping, optional parameter type checking, optional lazy evaluation, among other things. The goal of Sigil was to eliminate arbitrary, unnecessary distinctions in a programming language, such as the distinctions between programs and data, classes and objects, properties and methods, functions and language constructs, etc. I'll add a little more information at a later date. For now, you can download the source code or view the language reference manual

is a simple programming tool for scripting languages (Perl, PHP, Python, Ruby, TCL) written in Obj-C/Cocoa.
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.

is a general purpose computer programming langauge that avoids the syntatical tedium of langauges such as C, APL, and assembly, but includes the useful features of these languages. The three main goals of the Sirius language are 1) ease of use, 2) efficiency, and 3) portability. The syntax will be most familiar to Pascal and BASIC users. Like C, only program structures (such as loops, IF...THEN constructs, identifier declarations, etc) are defined by the compiler itself. Most "statements" are routines linked in at link-time. The richness of Sirius is derived from its small number of compiler constructs, the flexibility of the variable definitions, and the number of standard library functions. The compiler knows about these standard routines and performs automatic data type conversion where necessary, yet allows the programmer to redefine any routine as if it had never been defined in the first place.

is a Smalltalk/Self dialect and environment
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.

(SB) is a simple computer language, featuring a clean interface, strong mathematics and graphics. We feel it is an ideal tool for experimenting with simple algorithms, for having fun.

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.

Socket Script
- SScript is a socket scripting language that allows you to easily make networking clients or servers to accomplish simple tasks.

is a high level imperative/OO programming language, designed to be a powerful scripting tool that fits in the size, memory bandwidth, and real-time requirements of applications like games.

is an advanced scriptable RPN calculator for Mac OS X. It features the GNU Kawa Scheme interpreter which allows users to build custom functionality by way of short Scheme programs, or scripts.

is a complete, integrated application platform - a system for developing and deploying applications without the frustrations of integrating multiple different products. Suneido incorporates an object-oriented programming language, client-server relational database software, and application frameworks and components. It includes the development environment used to create applications as well as the client and server required to run applications across networks. Suneido is Open Source - it is provided free, with complete source code.

is an object-oriented language that is entirely based on XML's syntactical structure. Superx++ conforms with the XML version 1.0 specification as published on the W3C web site. Programming in XML itself has great potential and Superx++ pushes the envelope!

No comments: