ZPE Programming Environment

ZPE is built-up of several core components, namely the YASS syntax and byte-code (or op-code), the Zenith Parsing Engine 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 Zenith Parsing Engine itself works with the language by looking at the ZenithJSONParser file here.

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 IAST (Inline AST, formerly the Flast AST). The IAST is then run through an optimiser (only if being compiled to a file). The runtime will then run through the IAST 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. ZPE is considerably faster due to redevelopment of my parser (now known itself as the Zenith Parsing Engine).

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
• Code compilation and exporting
• Interactive mode
• A Graphical user interface editor
• Command line arguments
• On-the-fly interpreting
• Input and output
• Variable assignment and substitution
• Condition expressions
• Selection (if statements and select statements)
• Loops - both fixed and conditional
• Functions and nested functions, function calling and nested function calls
• YASS core function overwriting/overriding
• Optional parameters
• Finite sets (arrays)/lists and functions
• Maps (similar to dictionaries or associative arrays) and functions
• Overloading on functions. Mean, mode, max and min are functions that work on lists and numeric parameters
• Mathematical and logical parser (LAME)
• Recursion (since version 1.3.5.60)
• Native functions written in Java
• Library support
• Lambda expressions and anonymous functions with functions as first-class citizens
• Object-oriented syntax
• Structures and classes
• Optional variable and property typing
• Built-in classes
• Hundreds of predefined functions
• ZPE Online cloud storage
• A choice of strong or weak and dynamic or static typing when needed
• ZEN networking abilities
• A web parser, similar to PHP
• An open source standard library, written itself in YASS.

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