ZPE Programming Environment

ZPE is built-up of several core components, namely the YASS syntax and byte-code (or op-code), the ZenithParser which parses YASS code to byte-codes, the YASS Compiler which converts the byte-codes to an abstract syntax tree and the runtime which ultimately runs the program.

The following image shows how it works:

How ZPE works with plugins and libraries

The YASS Compiler's core principle purpose is to develop intermediate code. This code is then either run or it is compiled.

You can see how the ZenithParser itself works with the language by looking at the ZenJSONParser file here.

There are lots of functions:

Returns in Java are the YASS equivalent: return ( $v )

In Java maths is written like: int v = 1 + 1 and in ZPE as of version 1.3.5.60 it is written as $v = 1 + 1

Expressions can be nested: print ( floor (1.42) + 1)

You can read more about the syntax by clicking on Documentation at the top of this page.

Prior to ZPE I had already developed a programming language that I began to write when I turned 18 called BlackRabbit Script. The language was slow. But when I began writing a spell checker for Wonderword, I learned more about things like BNF and parsers I began rewriting it. Further, BRS was limited to Windows.

I think it would be fair to say that I began building this down to my own research and knowledge, but that my university course definitely was the push that made the performance almost double after learning about LL(1) parsers where I was converted to remove backtracking almost all over the parser.

ZPE and YASS were started in January 2015 as a programming project I decided to start for fun (as with all of my software). In March I could see it was really coming along as a programming syntax and thought I might as well continue with it. From there on, what was originally called only by it's codename, Shifting Sands and Stratosphere, became something else.

Just as BlackRabbit Script worked on .NET, ZPE works on Java. The two were fundamentally and syntactically different. Both were variations or dialects of my own BlackRabbit Script. YASS as it is known was fully based on the same syntax as BlackRabbit Script started on.

YASS and the ZPE Programming Environment are designed as a small compact programming language that can be used within other applications as scripting languages, but they also both feature stand-alone functionality as well. The core aim of the language was to improve the readability of code to make it easier to learn, therefore the language can also be seen as theoretical and educational languages too.

ZPE is an LL(1) parser that will compile code from YASS to byte-code. The parser requires the use of backtracking and does this incredibly well. By doing things this way, it can assess mathematical expressions in one simple function rather than needing other methods.

Code is converted from byte-code to a FAST (Flat AST). The FAST is then run through an optimiser (only if being compiled to a file). The runtime will then run through the FAST and decide what to do based on the byte-code of each AST.

There are very few regular expression evaluations used in the language which is designed to keep the compile time down.

Compiled files will run faster than interpreted files, but interpeting code still runs relatively quickly.

BlackRabbit Script is the predecessor to ZPE/YASS and is a scripting language written in C# and VB.NET. It was more of a kind of side project than ZPE became. It is considerably slower.

A lot more time and effort went into the development of ZPE than BRS because I had a lot more of a plan when I developed it.

In terms of performance, ZPE is considerably better. In both languages I wrote the same for loop that does the same thing (loops 100,000 times):

for($i = 0, $i < 100000, 1)
	print($i)
end for
										

The newly designed ZPE performs nearly twice as fast as it did at the start of 2015, and considerably better than the .NET version of 2014 and the original version of 2011.

The following graph shows system times in milliseconds to perform a loop that prints each number up to 100, 000 times:

Scores are calculated by determining time in milliseconds taken to do the same task with better results being the ones that takes less time as shown above. Note, the right two bars are versions of BRS and the left bars are versions of ZPE (with the second bar being ZPE 1.2).

Many features have been suggested by testers and users of the language, although the majority are my own.

The following core language features have been implemented as of now:

• LL(1) parser
• Tree generation
• Compiling and interpreting code
• Line reading mode to take individual commands
• Graphical user interface mode
• Command line arguments
• On-the-fly interpreting
• Core functionalties such as print, arithmetic and string manipulation
• Variable substitution
• Variable assignment
• Condition assessment
• Bracketed logic and math
• If statements
• Loops
• Functions and nested functions, function calling and nested function calls
• YASS core function overwriting - write functions over core functionalities by defining a function or defining a custom function
• Optional parameters
• Finite sets/lists and functions
• Associative arrays/maps
• Methods that are multi-functional. Mean, mode, max and min are functions that work on lists and numeric parameters
• Mathematical parser
• Recursion has been available since version 1.3.5.60
• 100 or more built in commands
• Native functions written in Java
• Library support
• Lambda (λ) expressions and anonymous functions
• Built in sort algorithms
• Full support for structures
• A standard library, written itself in YASS, open and compiled and designed to showcase the power of the language.

The following core language features are being developed at the moment and will be available soon:

• Export to Java

The following core language features are being considered and may come soon:

• Export to C, C++, VB.NET, C# and Python

There is more in the changelog as to what has been added. You can find the changelog here.

I do regret to inform everyone that I no longer have access to the old versions due to them cluttering my system. I decided to stick to the current version of ZPE code and the three build versions back (so if was writing code for 1.5.0.1 I could still access back to 1.4.3) came to an end at the start of 2017.