Emerald:



Emerald is a language I have theorized for a long time.  I have finally decided to make this
my primary project!  I choose to present it here cautiously, not because there's competition
but rather due to the entirely new form of syntax and ideals it portrays.  An example of the

syntax:

~seep classpath

define ostack Felines further
   accept Cat, etc
   expand
/further

define type Cat further
   String Name null
   define creator Cat void (String Name) futher
      set Name
   /further
   define action Meow void () further
      pusln("Meow".."/n")
   /further
/further

generate from Felines Cat("Mimo")
Felines.entry[0].Meow               #ouputs Meow :P

ostacks are a main feautre of emerald.  Ostcks are object stacks, which essentially hold
unnamed objects in an indexed format.  This is one theory I thought HAD to be included, and
is really awesome because to create a new one all you have to do is use 'generate' and say
which stack you add it to.  The stacks can be set to accept only certain types, but the
'etc' commands allows for you to later define types that can be inserted into the stack.  
Everything in the stack inherits traits from a higher class -- but I didn't use it ion this
example.

Weird concept, but I personally think it's awesome. That's just one of the surprises in Emerald Coding -- other features include:

- compiles to interpretable bytecode
- full support for object oriented programming
- new additions to the original object oriented approach
- very user-friendly syntax
- easy to learn new concepts that extend modern OOP
- low benchmarks for easy VM translation
- interpretable bytecode can be run at speeds similar to Java and other non-direct compiled languages
- very small program size

One thing that may seem trivial at first is the use of object stacks to hold similar types (Emerald name for classes).  Stacks can have a mainframe type that all objects in the stack inherit properties from.  This allows for easy inheritance that can be applied at any time to specific objects.

All attributes of an object in Emerald are hidden and must be accessed through actions (methods).  Example:

generate from Felines Cat(3)   # 3 == age

int KittyAge Cat.Age          #illegal
int KittyAge Cat.GetAge()   #legal
int KittyAge (generate from Felines Cat(3))   #even better!

[More info later]





VixenVM



A low-level minimalistic VM for interpreting Emerald Bytecode!  Includes minimal GC, threading control, and forwards compatibility with higher-level VM implementation methods!

Features include:

- multi-threading (up to 256 threads at one time)
- program-denoted garbage collection
- preloading of bytecodes to ensure speed while interpreting
- minimalistic design for implementations on lesser technologies

[More info later]

Sounds awesome! we should create an interpreter for calcs if its finished!

That's the thing it IS for calcs specifically the prizm, but maybe I'll make a version of Vixen that even is supported on an 84+

Ashbad, I'm sorry if I'm rude, but how many languages have you said you'd make so far? I can count 3, not being rude, but perhaps you should try and finish your projects before starting new ones because your finished ones look great (Pyyrix, Vector Tunnel, Trio and Nikko demo).

Especially for calcs, making languages for calcs is even harder.

Either way, good luck!

those languages turned out to be poorly planned and stupid.

most great languages have had many incarnations before they came into being.  This is the same.  Good day, sir!

and scout, what makes it harder to have it on calc? it really isn't any more difficult, and in many senses much easier, since you have less limitations OS-wise, and the prizm is a perfect platform to kick this off on

thanks for the heads up qwerty

also, I mean low-level in more of a 'minimalistic' sense sorry if I didn't express that clearly

thanks for the heads-up DJ

also, I'd be glad to take ideas.  I don't really need any to make this great, bu I would appreciate anything anyone has to offer.

it will actually support integers of defined length of course it will have 16 bit integers as default, but you can declare them as 8 bit to 64 bit.

yeah, I want low and high level support on this

Any ideas?  Please express any ideas you may have here

As a suggestion, try to not make the interpreter and editor ridiculously massive. If someone wants to play Pong, he's not gonna download an extra 1 megabytes interpreter, plus it would take a long while to transfer to the calc anyway.

Also make the editor user-friendly, because for example with BBC Basic for the 83+ people were turned away by the editor.