_{Jamie Balfour's}Personal blog

ZPE 1.12.7 is now available to download. This version brings sweeping changes to the way that libraries are imported into YASS code and the ZRE; it introduces bubbling, brings breakpoints to ZPE, fixes an issue with permission levels not being read correctly, and, perhaps most importantly, adds unescaped string literals to the YASS language.

All of these features makes ZPE 1.12.7 one of the most jam-packed releases of ZPE to date.

Here is a program for a linear search I wrote in YASS some few months ago.

function linearSearch($item_list, $search_item) : number | boolean {
  $found = false
  $index = 0 
  $position = -1 
  while ($index < count($item_list) and $found == false){ 
      if ($item_list[$index] == $search_item){ 
       $found = true 
         $position = $index 
      }
      $index++ 
    } 
  if($found){ 
      print("Item found at position", $position)  
  } else{ 
      print("Item not found")  
  } 
} 
    
function main(){ 
  $l = [3, 5, 7] 
  linearSearch($l, 6) 
} 

And here it is converted to Python using ZenPy:

def linearSearch(item_list, search_item):
  found = False
  index = 0
  position = -1
  while index < len(item_list) and found == False:
    if item_list[index] == search_item:
      found = True
      position = index

    index += 1

  if found:
    print("Item found at position", position)
  else:
    print("Item not found")


def main():
  l = [3, 5, 7]
  linearSearch(l, 5)


main()

I have been seeking to add breakpoints to ZPE for the last seven years, and I have finally succeeded. 

They work using the new bubbling technique I have developed. In ZPE, bubbles are exceptions; a breakpoint is a simple bubble. Bubbles go all the way to the top of the runtime and are handled by the parent. Complex bubbles work entirely differently, and although they are also bubbles, they can be handled by different parts of the program. 

A breakpoint is added to YASS code by writing #breakpoint# where the code should break. In the GUI mode, it will display a variable watch window:

Another prominent feature brought to ZPE this year is bubbling. ZPE will introduce bubbling with version 1.12.7. It is used for interrupts such as exit requests, errors, and breakpoints. These are called bubbles since they are up to the program's top. So, for example, an exit request no longer exits ZPE; it handles a bubble instead to decide what to do with it (and, of course, that might be to exit, or it might be to close the active thread).

Bubbling is a huge feature that changes many of the underlying implementations of ZPE.

One of the significant updates coming to ZPE 1.12.7 is a major change to how ZPE handles library imports. This post is designed to outline this change so I can reference it from the changelog and GitHub commit. 

Before this version, ZPE would read in library imports from a yex file in the libraries folder. This hasn't changed. The library files themselves need not be recompiled. However, the way they are imported has changed. In the older version of ZPE, a library was imported as a variable with all the structures and classes being defined within them:

import stdLib
print($stdLib->bubble_sort([2, 7, 1, 6]))

In ZPE 1.12.7, this changes. Now, instead of adding the bubble_sort function to the $stdLib object, the bubble_sort is put into the top level of the runtime (i.e. added to the global function), so instead you would call bubble_sort:

import stdLib
print(bubble_sort([2, 7, 1, 6]))

ZPE 1.12.7 also allows doing this in the old manner by using the new import as syntax:

import stdLib as stdLib
lib = new stdLib()
print(lib->bubble_sort([2, 7, 1, 6]))

This new change will make some difference to the way in which libraries are used and will improve ZPE performance and memory footprints.

I recently started working on the YASS to Python transcompiler. It's worked well over the last few weeks, and I've decided it needs a proper name. 

Without further ado, let me introduce ZenPy. 

ZPETypes were first introduced to ZPE a few years back when the move to 'everything as a function or object' concept evolved. This paradigm shift made it impossible for ZPE to encounter data types such as BufferedImages as it had previously, restricting such data only to ZPE structures (and, indeed, ZPEObject instances). This tidied up the core of ZPE, improved performance, and caused fewer crashes.

Now, I embark upon perhaps the most exciting yet ambitious project in ZPE's history: shifting away from generic values to ZPETypes for all return values. This is not going to be a quick job either, and it could take several days of development. But it's necessary to make ZPE feel more solid and improve performance even further. 

ZPE is close to its 100,000th download as of this year, so it is time for this change to come around. I seek to have it done by the end of the summer.