Welcome to Conseptizer.org


Sitemap

Main page
  Download
  General FAQ

Language
  Overview
  Tutorial
  Lang FAQ

About us


    Conseptizer
programmers' coding canvas
News: Work on the new interpreter is progressing. Memory management is working and we're now implementing the bytecode compiler and engine. Also, we had large discussions about what prevents programmers from using non-mainstrem languages and we're going to tackle the issues we found one after another.
"They who would give up 
essential Freedom, to purchase
a little Type-Safety, deserve
neither Freedom nor Type-Safety."

(Benjamin Franklisp)

Conseptizer is a stack-oriented programming language with focus on list-processing. It offers powerful features that cannot be found in mainstream languages today. Here is what this means in detail:

* It uses the power of list-processing.
Like languages from the LISP-family, Conseptizer puts an emphasis on using lists as a generic data structure (though of course others are supported as well). This increases code reuse a lot. Even program code consists of lists, which makes it easy to write code that processes or transforms program code (meta-programming).

But while Conseptizer is quite similar to LISP, it makes it more evident how code gets evaluated by providing some more visual clues for quick orientation in source code than LISP does (but macro power remains, of course). It also greatly reduces the amount of nested parenthesized expressions that LISP became infamous for - this is one of the effects of the second paramount feature:

* It takes advantage of a universal stack-model.
While in most languages you apply values to subroutines, stack-based languages like Forth, PostScript, Factor and Conseptizer use a data stack that subroutines can use to freely pass arguments and return values. This adds an additional level of expressiveness, since it allows to combine elements and to form abstractions in new ways.

But unlike other stack-based languages, Conseptizer uses a rather traditional program notation which more closely resembles the way subroutine calls and statements are done in more conventional languages. This is very flexible and works well together with the LISP-concept of programs being written down as lists.

Additionally, the implementation of Conseptizer is Free Software, giving you freedoms like the permission to redistribute it with or without modifications. It is distributed under the terms of the Internet Systems Consortium (ISC) License, which is a very permissive and simple (non-copyleft) license.

May all benefit from the power of Conseptizer!



Examples:

# Add all numbers:
sum: (each $+ x 0)

# Open a file:
if (open 'read File-Name)
   | Src (process-data Src)
 (err "couldn't open file")

# Iterative fibonacci:
fib: | N
(1 0;
 times N | A B (+ A B, A);
 //)

# Creating XML data:
My-XML:
<div style="align:justify;"
     id="foo">
 "Hello, " Name "!"
</div>

# List mapping:
map: | sub # L -> New-L
(when (cons? .)
  (recons $sub $re))

# Create a subroutine that
# gives us next item from
# list on each call, re-
# starting at beginning
# when reaching the end.

value-circle:
(L|: circular;
 (L: xuncons L));

next: value-circle
 '(apple banana cherry);

next; # -> apple
next; # -> banana
next; # -> cherry
next; # -> apple


Copyright (C) 2014 Wolfgang Jaehrling

Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is here.

Contact: <wolfgang at conseptizer org>

Hi, I'm Karla - the official mascot of Conseptizer!