| Related sites for http://wouter.fov120.com/proglang/ |
| Sun_Valley_Systems Collection of COBOL programs, routines and files that have been written over some thirty years of programming and have been placed into the Public Domain by Judson McClendon. | | Digital_Brand_Expressions Optimizes clients' brands, marketing, and communications ensuring synergy across media (online and offline) and drives site traffic through brand-focused programs. | | HPFfe Public domain High Performance Fortran/Java front-end. | | S5_Systems_Inc_ Wireless application provisioning solution provider. | | Home_Page_of_the_xVRML_Project Home of the eXtensible Virtual Reality Modelling Language Project. It focused on evolving this into a more modern approach based on using an XML-based notation and an XML Schema -based definition. | | Atticus_Consulting Atticus Consulting provides complete RightFax solutions for network and production faxing, including integration with MS Exchange, Lotus Notes, Oracle, SAP and other ERP systems. | | Linuxconf_project administration system for the Linux operating system. In many ways, Linuxconf is different from other administration schemes found on Unix operating systems and most other systems. | | RFC_3153 PPP Multiplexing. R. Pazhyannur, I. Ali, C. Fox. August 2001. | | RFC_0923 Assigned Numbers. J.K. Reynolds, J. Postel. October 1984. | | ASP_Development Collection of ASP, ASP.NET articles and tutorials. Features ASP development discussion boards. Also SQL, and JavaScript articles and tutorials. | | Chilling_Effects_Clearinghouse__Domain_Names_and_Trademarks FAQs and advice on how to defend against claims of domain name trademark infringement and other legal scare tactics, compiled by students at the Berkman Center for Internet & Society at Harvard La | | Pop-up_Barrier Blocks all incoming messenger service advertisements for Windows XP. | | Boost_Consulting Dedicated to support and development services for the Boost libraries and associated tools. The Boost libraries are a peer-reviewed, open collaborative development effort. | | Tile_Sliding_JavaScript_Game Puzzle based on the classic 15 Slider game. Varying difficulty level. | | LizardWorks_TIFF_library Read and write TIFF (Tagged Image File Format) files with application and applet examples. [Open Source, LGPL] | | NeoOptic Design, multimedia, database construction, copy writing, print, CD-ROM, photography, and illustration. Located in Norfolk, United Kingdom. | | Magnus\'_C64_Games A collection of about 200 games with screenshots and descriptions. Games are grouped into genres. | | The_Build_Games Lists screenshots and information about the games that were written using the Build game engine. | | Cheat_Chaser Features pokes, hints and tips that will let you conquer hundreds of C64 gaming titles. | | Industrial_Solutions_Group CMMS and enterprise asset management EAM maintenance software specialists providing Maximo and Datastream CMMS. This group specializes in CMMS training and CMMS consulting. |
|
Wouter's programming language page
Programming Language Design and Implementation
This page basically gives a historical overview of all the
programming languages I have designed (and sometimes implemented)
over the years. Some of them, notably
E,
False,
Bla,
Aardappel and
SHEEP
have their own pages.
Language Design history & overview
(REVERSE chronological)
Bear (aug 2005)
More complete language design that integrates a few recently researched features, but its main focus is on
a very clean and seamless unified macro/function/class/coroutine system for the ultimate in (re)factoring power, and also uses the ownership
reference counting model below, etc. In general, this is a less adventurous design, more targeted towards being able to build an implementation
that is practical and very fast.
Toad (july 2005)
A string based language whose sole purpose is to be able to be implemented in as few
lines of code as possible, while still being a "complete" programming language usable by
average programmers. Goal to be used as a tiny plug in language for simple scripting/configuration.
[staged_computation] (may 2005)
an attempt to elegantly move from the two stage compile-time and run-time to N stage model,
by adding any number of stages in both directions.
Horse (apr 2005)
generalizes the concept of a spreadsheet to aritrary tree
structured data, but keeps the grid based view. Also allows
more complicated computations/functions to be specified using the existing visual representation, making it into
a beginner friendly graphical programming language.
KNOFLOOK (oct 2004)
A tree based graphical programming language/environment whose primary aim is to do away with explicit abstractions
completely. The environment allows programming by cut&paste, keeping code factored automatically, with no need to
create "functions" explicitly. Paper "Abstraction Considered Harmful" forthcoming.. :)
[ownership_reference_counting] (june 2004)
combines linearity and reference counting for cycle-problem free very fast automatic memory management
[flat_file_memory_management] (june 2004)
Stores all memory used by a program (a tree) as a flat, "inline" structure with
no pointers (!), just offsets. Uses the MMU to reallocate virtual memory to make inserts/deletes
of tree nodes bearably efficient. Has as big attraction that it makes memory management
trivial, and very space economic (in most cases 16bit offsets can be used instead of
64bit pointers, this can be decided on a per-page basis).
Frog (dec 2003)
Another attempt at using a stack language for graphical programming, much like growing_example_stacks below. This time
tries to reduce the need for mentally picturing the stack by always showing the state of the stack inline with the code
from the perspective of the instruction currently being edited/executed.
CryScript (aka DOG) (nov 2002)
Scripting / Game programming language I created for Crytek's next gen engine effort. Tries
to balance the friendlyness and conciseness of scripting languages with Java/C# level base language
for larger scale game programming. Strongly typed but can be used mostly without type annotations,
JavaScript style syntax, very convenient built-in vector and map types, classes, interfaces, exceptions,
region based memory management, dynamic module
loading & linking, automatically generated C++ native interfaces, compiler with strong optimizer & analysis component, very fast register based interpreter.
Beats well known other scripting languages by large margins.
Mature implementation (not available, this is up to Crytek).
Wortel (sept 2002)
Unifies coroutines, functions and classes into a single small construct.
NVNSRRML (feb 2002)
"Non Verbose Non Semantically Redundant Readable Markup Language", i.e. the antithesis to XML.
Also featuring ENVNSRRML (Executable NVNSRRML), a macro / document processing / transformation /
programming language.
MOLE (dec 2001)
MOLE is a family of languages rather than a single one, each one implements linearity as part
of an imperative language using different constructs and different levels of intrusiveness. Think
STL auto_ptr as part of the language & type system with Call by Name, using analysis to reduce the burden on the programmer.
Besides linearity, MOLE features a smalltalk-y syntax, hygienic macros, graph types, and minimalistic coroutines.
COW (june 2001)
COW is another "environment" language like Bla, but is much more radical in unifying all possible programming
language constructs into one (the environment). Extremely tiny language definition covers classes, objects, modules, functions/methods
function-environments, scopes, (recursive) lambda's, tuples, lists, arrays,
monitors, futures, bags etc. etc.
[linear_lazyness] (dec 2000)
An investigation into the interactions between linearity and lazyness, and possible optimisations.
PIG (oct 2000)
PIG is an "anti-functional programming language", an experiment to see how far one can get in a language
which only has global state (in the form of stacks) and argument-less functions. Inspired by OpenGL and the "move" cpu.
[feedback_trigger_VPL] (may 2000)
A graphical programming language based on (cyclic) dataflow, which embeds state into the
dataflow, making for natural definition of "objects", better code sharing, clearer dependencies, good seperation of
core & peripheral methods, and reduced dataflow connections. Easy "environments" and lambda objects.
See a mockup for a stack ADT here.
Goat (april 2000)
Specialised language that can specify binary (file) formats & possibly transformations on them, from
which a variety of translators, converters, browsers, editors etc. can be automatically generated.
SHEEP (feb 2000)
New scripting/querying/ipc/programming language I'm doing for Amiga Inc., with as
basis a not as hardcore version of Sheep. Expect familiar beginner friendly syntax and semantics
coupled with multimethods, automatic memory management without garbage collection (linearity), powerful
datatypes, pattern matching, strong and dynamic typing living together in harmony,
integrated access to all the new Amiga OS features, and optional compiled output comparable to C in speed and size.
More here.
Sheep ["hardcore" version] (jan 2000)
A fully linear (one reference) referentially transparent strict functional language with
inclusion polymorphism and easy usage of state & OS. Designed to be implemented to
allow for an extremely high level of optimisation (no
garbage collection, no aliasing, only in-place update, specialized dispatch).
WadC (dec 99)
A cross between a very minimal lazy functional programming language and a macro preprocessor.
Used as the language to program 2d line structures with intended as maps for the game Doom.
(more here)
UhOh (oct 99)
A cross between Monads, Backus' FFP, and my Ni! and Kartoffel languages. Uses
a friendly version of Monads layered into FFP's higher order functions to allow
for easy (compositional) state, io, exceptions etc., in a referentially transparent language.
Aardappel [optimized] (jul 99)
Simplified the original language greatly by removing function values (these can
be expressed in the language itself using specificity ordering).
(details here)
DaMaul (sept 98)
A very minimalistic "chemical reaction" type language in the same family as Linda & Gamma.
The only language construct left is the "communication" which react in pairs.
Boerenkool (oct 97)
Another design for a graphical programming language, this time
based on tree structures with clever tricks for sharing, and
programming by example. Has now been integrated as the syntax part
of Aardappel, but idea can be applied to a whole class of (funtional style) languages.
Here is the full picture
Aardappel (nov 96)
(previously known as "Hekking" and "Sauerkraut III").
Does the obvious thing and combines the ideas present in Sauerkraut I, II,
Schnitzel and SchnitSauer to come up with a "Concurrent Tree Space
Transformation Language". Does visual tree rewriting with Linda type
concurrency, transformations (i.e. linearness + object identity) and other
neat things. Design has been polished a lot during '97.
(see its own homepage)
[alt_pattern_match]
Shows a syntax to have left and righthandsides of rewriting as one huge
expression, and some various weird ideas.
#:append([],*)
[#:append([*|T],Y)|append(Y,T)]
Sauerkraut II (nov 96)
Extends Sauerkraut with dynamic contexts to match onto.
Schnitsauer (oct 96)
Attempted to combine dataflow and Linda into a general visual concurrent
component type language. made to be very compositional and flexible, inspired
on Schitzel.
[principles, bags] (sept 96)
Sums up some of my general language design principles, and explains
why the various languages below based on Schnitzel and Sauerkraut are
so great. Deals with "Reducing the Complexity of Dependancies".
BRAAF
Computing with single-value objects that trigger bits of code upon
reading/writing.
[fundamental_reuse]
On how reuse works and why the traditional ways of doing so
(including OO) don't work.
Schnitzel (jan 96)
An even simpler design for visual programming based on Linda tuple-spaces.
looks even less like programming.
Sauerkraut (dec 95)
A completely different attempt at a VPL: using term-rewriting
and bags, and a new evaluation scheme. (related to GRRR, GRR, UHH, UH)
Kartoffel (nov 95)
Uses a system of higher order functions similar to Backus' FFP language
to create a visual language. layout is purely composition of boxes into
bigger boxes. "Kartoffel" is the ascii version.
[no_methods_oo] (jun 95)
An OO language that uses just reading/writing/creation/deletion as messages to
an object.
GRMPF
A purely functional language with novel syntactical constructions to
make programming more practical in context of ADTs etc.
pop(pop(s):a):b
Apfelstrudel
Unites all previous VPL layout methods into one semantical framework
with possibly different representations.
[inheritance_harmful]
Functional alternative to OO: uses compositions of terms and delegation
relations between them, and transformations instead of patternmatches.
(related to Ni!)
Point = Loc:Col(c) {
Inverse Point(c=C) = Point(c=256-C)
}
[growing_example_stacks]
Trying to reduce the visual complexity of VPLs: using stacks with example
values in them.
UHH (mar 95)
Programming by example using bags.
UH (feb 95)
1st class concurrent bags. Linda meets Actors meets BRAAK.
{
numphil:5
---
c c eat:P => ok->P.
numphil:X>0 => numphil:X-1 c room:*->{
hungry
---
hungry `room:R => eat:*->R.
ok `room:R => c->R c->R hungry.
}.
}
Ni! (feb 95)
Study on polymorhism, and how a system based interfaces and certain
compatabilities between them should be more powerful and compositional than
OO.
GRR (jan 95)
Term rewriting language meant as language implementation tool, featuring
higher order patternmatching that can be used both as grammar (parse+lex) and
transformation/generation. (related to GRRR). (see an
example).
Bla (end 94, unix/amiga/...)
An unpure functional/OO language, strong typing + TI (makes the ideas
already present in Blerk into a solid and usable design). Implemented in C++ as
a compiler to portable bytecode (the Emmer intermediate language) which
could then be interpreted etc. After the initial paper end `94, Bla was
fully developed and changed quite a bit during almost all of '95. Have a
look at the Bla homepage .
X780040 (end 94)
General low-level virtual machine design, meant to support both Bla and Plop,
and anything else.
G (aug 94, amiga)
Graphical dataflow language. details various forms of efficient non-concurrent
evaluation, and various DAG layout algorithms, possible type-systems etc.
Also ascii syntax design without identifiers, and how to
how to enhance compositionaly and reduce dependancies between software
components (not overly succesful). OO variants considered.
A prototype implementation (a dataflow editor) was started.
 
[lazy_generators] (jun 94)
Reinventing the wheel: the deforestation optimisation for lazy FLs. uses
composable generators ipv interim lists.
GRRR
Actually various designs in one, all based on term/tree-rewriting / equational
logic. meant also as compiler toolkit. many evaluation strategies
considered.
_:E' = S:E
_:E'' = stats(R):E''
=====================
stats(S:R):E = []:E''
BRAAK
Forth meets Prolog: stack language that uses unification to retrieve
values from stack instead of push/pop, or Ordered Unification Spaces.
append:[ O L L nil O ]
append:[ O H:T T O append X H:X ]
OOHNO! (jan 94)
Fundamentalistic dynamic delegation OO language. very primitive, small
language core. very "Self"-like.
stackt |
|
