ZIDE or ZPE IDE is a powerful new IDE that I've been developing for quite some time. It's powered by ZPE and takes a lot of what makes the ZPE built-in editor so powerful. ZIDE is designed to support multiple languages and runtimes, whilst being flexible and yet powerful.
But what's really awesome is how many features ZIDE now has; here's a list of my favourites:
- Git and GitHub integration
- ZPE Online
- AI Assist and AI Build
- Full error detection
- Debugging tools including breakpoints and stepping through code
- A built-in terminal
- Proper syntax highlighting for both ZPE/YASS and Zpeedy
- Python support - code highlighting, error detection and runtime support
- MD support
Tomorrow marks my final day as a teacher. While I'll still be doing some supply teaching over the next few days, this feels very much like the end of a significant chapter in my life.
Looking back over the past eight years, I can honestly say that teaching has been an incredible experience. I've met some fantastic people along the way, worked alongside dedicated colleagues, and had the privilege of teaching so many wonderful young people. There have been countless moments of laughter, pride and genuine joy that I'll carry with me for years to come.
I've also done quite a bit as a teacher, developing over 200 lessons' worth of materials, including slides, worksheets and supplementary materials. I have taught my area of expertise in computing and have gone above and beyond expectations in my subject knowledge, for example, when discussing interpreters and compilers or agile methodologies. I have led the school's digital champion program (not at my current school, but it was on the cards) and increased computing numbers (for example, from 8 pupils to 51 in one year). I developed my own slideshow engine, DragonSlides, which allowed pupils to join interactive lessons where they answered questions or completed tasks on the slides as we went through them as a class. I developed DragonDocs, which provided pupils with much more interactive worksheets and assessments. DragonDocs also uses AI-based, context-aware marking to ensure marking is fair and equal for all.
Of course, it hasn't all been easy. Like anyone who has spent time in education will understand, there have been challenges, frustrations and difficult periods that tested me both professionally and personally. Some of those moments brought me down and made me question whether I was on the right path.
Despite that, as I reach the end of this journey, it isn't the challenges that stand out most. Instead, I find myself looking back with a real sense of gratitude and, if I'm honest, a little sadness. Eight years is a long time to devote to something, and teaching has shaped a huge part of who I am.
While I have made the decision to move on, I leave with far more good memories than bad ones. I'm thankful for the people I've met, the lessons I've learned, and the experiences that have helped me grow. As one chapter closes and another begins, I'll always look back on my time in teaching fondly.
Me teaching back in 2016
As I posted on my Bluesky account earlier this afternoon, I'm now using GitHub Actions to automate the deployment of ZPEX, native ZPE plugins and the plugin bridge for ZPE.
Not only does this mean they're easier to build since I don't need to maintain three machines to compile on, but it also means deployment is smoother and more continuous integration. On top of that, ZPEX, native plugins and bridge updates are all automatically pushed to my website (or, for the bridge, pushed into the next version of ZPE).
The goal over the next few weeks is to ensure tight integration of the new GUI and the new plugin system with both ZPE and ZPEX. I also intend to build every ZPE plugin this way over the next few days, especially since it's now so easy and automated.
ZPEX has long held the banner for performance and, more recently, has outperformed PHP and Python in the latest performance tests. However, its compatibility layer with ZPE plugins has always plagued it, meaning it wasn't a full package like standard ZPE.
Well, thanks to some clever ideas and some assistance from AI, I have developed a bridge that lets these plugins be used, but in a slightly different way. Here's how this works:
- Each JAR contains its own plugin
- Each JAR is also compiled as a native plugin (dll, dylib, so) that can be used with ZPEX.
This way they do exactly the same thing, but work with different systems. In addition, import still works the same way; no changes are needed for either.
In addition, ZPEX now has a UI builder. Yup, you read correctly. A UI builder for ZPE and ZPEX. And it's clever. It works using an underlying C library I've written/am writing, which uses JNI to provide native bindings to AppKit, Win32, and GTK. UIs will, for the first time, look different across operating systems, rendering engines, and layout engines, but this is to be expected and is actually fine by me. Components are fully native this way. too. Here's an example of a program made on macOS using the new UI object.
ZPE 1.14.9 is a major release that introduces ZenC and direct machine-code compilation with fat native plugin support; interfaces, enums, records, typed arrays and indentation-based YASS syntax.
It also introduces WebUI, a new HTML-powered UI that uses the same code as the current UIBuilder object (plugin). WebUI is powerful and compatible with ZPEX.
ZEQL is now in ZPE, making it easier to parse lists, maps and other collections. Databases are now accessible from within ZPE itself and no longer require plugins. Cron scheduling is now fixed and works. Project-resource bundling is now a thing; you can bundle resources with a compiled program, and it will load them when needed. The new ZPE Program Decompiler (ZPD) allows you to decompile compiled programs and makes massive improvements to inheritance.
TYPO v3 is also now included and it's fast and powerful, structure names can now be used as data types, for example:
Animal x = new Animal()
Where Animal is a user-defined structure.
ZPEX now also supports native plugins, and this support will grow over the next few months.
ZPE 1.14.10 aims to add support for new types, with TYPO 3.1. Specifically, with collections:
list
map<number, string> = [=>]
Take a look at the tracker to see what I'm actively working on.
In addition, one of the core changes being made to ZPE is moving IAST construction from the YASS Compiler to the new Byte Code Builder. This will allow other programming languages, such as my SQARL Runtime, to utilise ZPE's runtime, compiler, transpilers, and more, without first having to write YASS code. The foundations for this were set in ZPE 1.14.9, with the whole standard algorithms being representable in any language using the builder.
In the nick of time before release, I've just finished the interfaces in ZPE, and they're ready for release. I'm planning on releasing this as part of ZPE 1.14.9 after all.
public interface Reportable public function print_report() end interface public structure risk_register implements Reportable private $risks = [] private $next_id = 1 public function add(string $title, string $owner, number $probability, number $impact, string $mitigation) : number $risk = make_risk(this->$next_id, $title, $owner, $probability, $impact, $mitigation) this->$risks = list_add_element(this->$risks, $risk) this->$next_id = this->$next_id + 1 return $risk["id"] end function public function print_report() print("") print("RISK REGISTER") print(repeat_text("-", 72)) print("Open risks: " & this->open_count() & " | Total exposure: " & this->exposure()) $ordered = sort_risks(this->$risks) for each($ordered as $risk) print("R" & $risk["id"] & " [" & $risk["state"] & "] " & $risk["title"]) print(" Owner: " & $risk["owner"] & " | P=" & $risk["probability"] & " I=" & $risk["impact"] & " Score=" & risk_score($risk)) print(" Mitigation: " & $risk["mitigation"]) end for end function end structure
Also, ZPE has now been tested with an 8,000+ line code program, and it still compiles it in less than 50ms! That's a major milestone right there.
Two of the most desired ZPE features, enums and interfaces, are now compiled within YASS. Both will be compilable from ZPE 1.14.9. Neither will currently be usable; however, due to the need for further testing, they will be left out of HYPR and ZPE's runtime.
In addition, ZPE now finally features a decompiler, the ZPE Program Decompiler (ZPD). It transforms the IAST, whether stored in a file or passed to it, back into a YASS program. As you'd expect, it's fast. The new ZPD will be bundled with ZPE 1.14.10 in October and not before.
Another thing to mention is that I've finally pushed Zpeedy Script to my GitHub account, and the source code is available for viewing. It's a descriptive language powered by the Zenith Parsing Engine v6, so it's fast. If my ZPD works perfectly, you'll also be able to generate YASS from Zpeedy (not vice versa, however).
ZPE Programming Environment has been my main project for over 11 years now, and it's so solid, so fast, and so feature-rich. As a result, I want a new programming language project and that new language is Zpeedy Script.
Zpeedy Script was first conceptualised in June and had been sitting for months with little work done until a few days ago. It uses the ZPE core, ensuring it runs fast, requires minimal development, and is well integrated with the YASS programming language. Zpeedy Script is incredibly descriptive, and code reads almost like a sentence. In my opinion, this will make it a bit more difficult for seasoned programmers to learn, but I've got plans to allow YASS to be included as well, and since YASS reads like many other languages, it should be really easy to mix the languages.
Below is an example of Zpeedy Script:
// Zpeedy Script language showcase
display "Zpeedy Script showcase"
// Public routines, parameters, calls and returned values
routine displayGreeting takes person
display person
routine double takes number
give back number * 2
routine add takes firstNumber, secondNumber
give back firstNumber + secondNumber
call displayGreeting with "Jamie"
set doubledByRoutine to call double with 10
set totalFromRoutine to call add with 10, 20
display doubledByRoutine
display totalFromRoutine
// Values, variables, lists and arithmetic
set name to "Jamie"
set enabled to true
set missingValue to nothing
set unknownValue to unknown
set startingNumber to 5
set doubledNumber to startingNumber times 2
set increasedNumber to doubledNumber plus 3
set calculatedNumber to increasedNumber minus 1
set animals to ["Dog", "Cat", "Fox"]
display name
display enabled
display missingValue
display unknownValue
display calculatedNumber
display animals
// Indentation-based conditions
if calculatedNumber is greater than 20 then
display "The result is greater than twenty"
alternatively if calculatedNumber is at least 12 then
display "The result is at least twelve"
alternatively if calculatedNumber is not 12 then
display "The result is not twelve"
otherwise
display "The result is twelve"
// Cached value selection
set colour to "amber"
set instruction to choice based on colour
"red" gives "Stop"
"amber" gives "Wait"
"green" gives "Go"
otherwise gives "Unknown colour"
display instruction
// Statement selection
when colour
is "red" then
display "Stop"
is "amber" then
display "Wait"
is "green" then
display "Go"
otherwise
display "Unknown colour"
// Boolean value selection
when enabled
is true then
display "The program is enabled"
is false then
display "The program is disabled"
// Iterate over every list value
for every animal in animals
display animal
// Conditional loop
set counter to 0
loop while counter is less than 3
display counter
set counter to counter plus 1
// Fixed repetition
repeat 2 times
display "Repeated"
// An indefinite loop can be stopped explicitly
repeat forever
display "The forever loop ran once"
stop loop
// Protected execution with an error-message handler
attempt
display "The attempted operation succeeded"
otherwise on error message
display message
display "Showcase complete"
I have been in my teaching career for 8 years now, and I have finally stepped out of it. This was an incredibly difficult decision because I didn't have a job to go to in the meantime, and I was also giving up a job I really enjoyed.
Maybe this is just a break, or maybe this is forever; I don't know. I just need to step away from it for now.
As the title says, ZPE is now able to connect to databases out of the box without needing you to install one of the plugins. This is great news, particularly for ZPEX.
A simple connection string using the new Database object allows you to connect straightaway:
$db = new Database("mysql", "127.0.0.1", 3306, "tester", "root", "password")
