Tuesday, February 14, 2006

J is for ...


is a library for Graphical User Interfaces (GUI). It was designed for quick and dirty use, cause its NOT object oriented. Therefor, it's easy to learn. Even beginners with little experiences in programming are now able to write first applications with graphical user interfaces.
The main goals of are:
  • Easy to learn and use.
  • Language independend. Currently can be used with Basic, C, Fortran and Pascal.
  • Platform independent. Written on one platform, the application should run on another platform through recompiling. Supported platforms are currently all Win32, Linux and Solaris.
JAPI is build on top of the AWT. The AWT (abstract windowing toolkit) is part of the freely distributed Java Developer Toolkit (JDK). The AWT is composed of a package of classes and it supports everything from creating buttons, menus, and dialog boxes to complete GUI applications. Notable, the AWT is platform indepented.
The functionality of the AWT is now brought to the (classic) programming languages via . So you do not need to learn JAVA. All you need is a running Java Runtime Environment (JRE) on your host.




is an interpreted computer language originally designed for programming text adventure games. Its migration to the web now allows the author to create a much wider variety of graphical and non-graphical programs, all of which can be used online using nothing more than a standard HTML web browser.


is a message based programming language. Execution of a Jargon program begins in the "Main" module in the "main" handler, which takes an array of strings as input. Variables and modules must be declared before use. However, handlers may be declared at any point within the module in which they reside. Jargon supports single inheritance of modules and overloaded message handlers.


is a MacOS X command-line tool that can execute scripts written in the scripting language HyperTalk. HyperTalk is a very english-like high-level language.


Like every other programmer with a pulse, I am compelled to create my own programming language. My compulsion is fueled by my day job, where I must deal with million line C++ programs. Jolt is the language in which I wish I could be programming.
Jolt is a system programming language intended to be used anywhere one would use C++. It is as willing to get dirty in the name of performance. It is not willing to compromise in the name of compatibility with legacy languages. It is a language in which everything is an object, inheriting from Object, including the primitive types, and yet is capable of implementing many of these same types in itself. It includes features traditionally seen in dynamically-typed object-oriented languages such as Ruby, and even has some LISP features, yet does so in a way that preserves strong static typing and the performance benefits thereof.
At the very least, the people who gripe that every new language looks like C++ or Java but with really neat feature X or minus really evil feature Y and why can't someone come up with something not so derivative... whatever faults they may find with Jolt that won't be one of them.
The current language specification may be found here. While it's meant to be an introduction and reference, it suffers from the stream-of-consciousness brain dump syndrome. I'll need to do an overhaul someday, but at over 120 pages (when formatted for printing) and growing, right now that would take too much time away from implementing the compiler.
Speaking of which, I have completed the parser and am starting on the semantic processing. If nothing else, this proves the grammar is LALR(1) with a minor exception or two. While I am not releasing any code at this time, I plan on eventually doing so under the GNU GPL.


is a purely functional programming language. Whereas all other functional programming languages are based on the application of functions to arguments, Joy is based on the composition of functions. All such functions take a stack as argument and produce a stack as value. Consequently much of Joy looks like ordinary postfix notation. However, in Joy a function can consume any number of parameters from the stack and leave any number of results on the stack. The concatenation of appropriate programs denotes the composition of the functions which the programs denote. One of the datatypes of Joy is that of quoted programs, of which lists are a special case. Some functions expect quoted programs on top of the stack and execute them in many different ways, effectively by dequoting. So, where other functional languages use abstraction and application, Joy uses quotation and combinators -- functions which perform dequotation. As a result, there are no named formal parameters, no substitution of actual for formal parameters, and no environment of name-value pairs. Combinators in Joy behave much like functionals or higher order functions in other languages, they minimise the need for recursive and non-recursive definitions. Because there is no need for an environment, Joy has an exceptionally simple algebra, and its programs are easily manipulated by hand and by other programs. Many programs first construct another program which is then executed.


Juliet is an open source programming language that I am designing. I am currently designing a compiler for Juliet called JULC, written in C++. The source code to JULC is freely available as described in its Readme file. Old versions of everything on this page are available in the Juliet Archive.

No comments: