1. Specs: Azure
Language name: Azure
This is a completely experimental project, including some rather odd OO-ish
constructs, variables and other things that will probably scare the sh*t out
of anybody :)
Some things have been borrowed from the dead and buried Magenta project,
perpetrated by Brian Connors in 1995.
The language itself is all about entities, their skills, and interactions
between entities and families of entities. For example:
string("Phone") -> global long_int
int("8726185") -> long_int.Phone
Everything is done by entities, even variable assignments.
Entities can send and receive data, and they have a couple of special signals
they can use.
All lines end with a ; (hybrid :) as in C and its spawn
Variable types:
int Integer, max 16-bit
long_int max 32-bit
short_int max 8-bit
char Normal 8-bit character
bin 16-bit binary value (internally converted to int to save
space, but represented as binary values?)
long_bin 32-bit binary
short_bin 8-bit binary
hex 2-byte hexadecimal (also converted to int internally?)
long_hex 4-byte
short_bin 1-byte
string String of chars.
bool Boolean, 1 (TRUE) or 0 (FALSE)
sequence As in Euphoria, nothing to it
aarr[a,b] Associative Array. a defines the data type of the keys,
b defines the data type of the values.
Example:
string("ID") -> private aarr[string,int],
int(3321233) -> aarr.ID.key("Tom");
This sets the key "Tom" to 321233
aarr.ID.key("Tom") -> int.Num;
would set int.Num to 321233
count[n,m] Variable starts with value n (int), and once it goes over
m (int) it rolls back to n.
path[x] Sort of a shortcut:
global path[Ctrl.Button.Spawned.MyBtn] -> MyBtn_;
All path variables must end with a _
***** OLD: [scope] type[parameters] -> name_of_variable
string("name_of_variable") -> [scope] type[parameters]
[sender entity] -> [receiver entity]
-> means SEND, the more popular one. The left-side entity must be capable of
sending, of course.
<- is REQ(uest), the not-so-popular-one. The right side entity must be able to
properly hande REQs _and_ SENDs
Scopes of variables, type qualifiers and stuff:
private Private to the entity it is declared in. No outside access.
global All entities may access.
paranoid Accessible only to related (spawned and otherwise) entities.
shared[a] Shared with entity a.
request[a<-b] Requests variable a from entity b. a must be shared or
requesting entity must be related to b.
After variable has been received, it acts like a private
variable, ie. no external modification.
Request is used differently from others
request[string.State<-Ctrl.TxtBox.Spawned.MyTxt] -> string.S
syncrq[a<-b] As request, except the value is shared between the two
entities. Sends an SREQ signal to entity b. See sync[] for
details.
syncrq[int.XVal<-Windows.Window.Spawned.MyWind] -> int.X
sync[b<-a, opt] Synchronizes the variable a with the entity (or entity family)
b, with options opt (opt is bin[4]):
1000 - Receiver may read
0100 - Receiver may write
0010 - Sender may read
0001 - Sender may write
famous The name of the variable is global, value is local.
Ie. may have different values in different entities.
Type qualifiers:
locked Constant, not changeable at all after first value is received.
Entities, skills and miscellany related stuff:
entity_family_name.spawn.NewEntity;
NewEntity knows {
[skills]
};
A Great Entity is the top of its family.
great.spawn.NewGEntity;
NewGEntity knows {
[skills]
} [ ];
NOT FINISHED YET
As I was thinking about an odd way of doing self-modifying code, there
would be no functions as such, only "skills", which can then be modified
during execution, and maybe even by other entities, depending on the
settings (r, rw, etc?) of the skill?
COMMENTS, please!
----
Get your free email at http://www.gnwmail.com
2. Re: Specs: Azure
> Language name: Azure from Tom Eklof
>
Wow! A VERY cool and innovative set of ideas!! This is really quite
refreshing. Please develop it with all haste 
Cheers!
--Warren
3. Re: Specs: Azure
On Sat, 24 Jul 1999 10:34:29 -0400, Tom Ekl=F6f <eu-list at GNWMAIL.COM> wrote:=
>Language name: Azure
>
>This is a completely experimental project, including some rather odd OO-ish=
>constructs, variables and other things that will probably scare the sh*t
out
>of anybody :)
>
>Some things have been borrowed from the dead and buried Magenta project,
>perpetrated by Brian Connors in 1995.
If it was such a great language, how come the Magenta project is dead and
buried ?
Probably because of it's rather odd OO-ish constructs, variables and other
things.
Bernie
4. Re: Specs: Azure
> >Language name: Azure
> >
> >This is a completely experimental project, including some rather odd OO-ish
> >constructs, variables and other things that will probably scare the sh*t
> out
> >of anybody :)
> >
> >Some things have been borrowed from the dead and buried Magenta project,
> >perpetrated by Brian Connors in 1995.
>
> If it was such a great language, how come the Magenta project is dead and
> buried ?
> Probably because of it's rather odd OO-ish constructs, variables and other
> things.
>
> Bernie
Jesus H Christ Bernie, I'm doing this for fun! It's not supposed to be a
competitor for C++, C, Euphoria, BASIC, REXX, Ada, LISP and all the others. It
just is.
It will never probably reach the same level as Euphoria, and I don't give a
damn. I'm just doing it for kicks, ok?
<End rant>
And besides, the OO-constructs in Azure are my own, not Magenta's. And yes, it
IS dead and buried, but I only borrowed some ways to do variables.
--Tom I-like-my-programming-language Eklöf
----
Get your free email at http://www.gnwmail.com
