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.
I have just made one of the most difficult decisions in my life.
Three weeks ago or so, I saw a post at Edinburgh Academy. I had always liked Edinburgh Academy (and as you may know, I also do one of their websites), and I was in a difficult position at work, which added to my decision to apply. And so I did, and I completed my application a couple of days ago.
I went for the interview, which I think went well. I taught a lesson before, and it went very well. I spent a lot of time preparing the lesson materials but did what I usually do and just naturally taught. In the actual interview, I was open and honest and felt right at home talking to the panel. I could see myself working here.
I was offered the job but needed to think about it.
Unfortunately, the journey was very difficult - and I only learned this on the day. Each way, it took around 1 hour and 30 minutes to travel. Compared to the five minutes down the road that I have at present, this was something I knew my body could not go back to (I remember doing this when I worked on the west side of Edinburgh back in 2017).
So, ultimately, my heart was set on the job, but my brain was telling me no.
I decided to decline the offer with great sadness. To me, this was not a choice—it was the only way this could go.
However, I still love Knox, and for that reason, it doesn't feel as bad a knock. I'm still glad I applied (and was offered the job).
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.
As games become increasingly demanding, the need for advanced hardware grows. Back in 2009, I had a Radeon 5670, a mid-range graphics card, which allowed me to run most triple-A titles at moderate settings. This was sufficient at the time, but as my interest in PC gaming grew, I wanted to play all my triple-A games on my PC. Consequently, I upgraded to a Radeon R7950, AMD's second-best card at the time, which could effortlessly run triple-A titles at full settings in 1080p.
However, the R7950 struggles with any modern titles at 1080p today, such as Warcraft 3 Reforged and Forza Horizon 4, due to its now modest 3GB of VRAM. Most contemporary graphics cards come with at least 8GB of VRAM, which is now considered the minimum for playing modern 1080p games at moderate settings.
Despite 1080p not being a high resolution by today's standards, running games with demanding graphics still requires significant processing power and VRAM. Even at 1440p, some computers with 8GB of VRAM struggle to handle the latest titles because of their high demands. The rise of technologies such as ray tracing and more detailed textures has only amplified these requirements, pushing even mid-range systems to their limits.
In summary, while 8GB of VRAM should suffice for 1080p gaming at high or ultra-high settings for some games, it falls short for 1440p gaming or higher at those settings, especially with high refresh rate displays (though VRAM does not directly impact refresh rate). For 4K gaming, I believe a minimum of 16GB of VRAM is necessary, regardless of the settings.
The rapid evolution of game graphics and performance demands has made it crucial for gamers to continually upgrade their hardware to fully enjoy the latest titles. This trend also raises questions about the sustainability of gaming habits and the financial burden of keeping up with technology.
I aim to spark a discussion on this topic and would love to hear your thoughts. Please send me an email or reach out via my website. Your insights and experiences with hardware upgrades and gaming performance would be invaluable to this conversation. Let’s explore together how we can best navigate the ever-changing landscape of PC gaming.
I do not particularly like the idea of using AI to write articles; however, I do like the idea of writing an article and having an AI rewrite it for you so that the quality improves.
This is a new area for me, and I'm looking to bring it to DASH in the next few months - a simple button press that rewords what you have written better. This has been very useful for me in the last few days, where I have relied on Grammarly AI to help reword phrases in some of the documentation for ZPE, for example.
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.
ZPE plugins are now available to download from my website straight from my Download Center. All plugins are open-source and can be compiled, modified, forked, etc., from my GitHub.
Currently, the only existing plugins are the libZPE-MySQL, libZPE-MQTT, and libZPE-Serial plugins, which were three of my original plugins. libZPE-Windows, libZPE-Mac, and libZPE-Linux are all underway now, too.
As you'll notice, if you are interested in making plugins for ZPE, they must follow the naming convention of libZPE at the start.
The plugin system, known as the ZIP System, is now working. It's replaced the older plugin manager with a more efficient and reliable system. I recreated the ZPE MySQL plugin yesterday and got it working again. Part of my plans for this include removing some of the features in ZPE, including the MQTT features and potentially the GUI features in ZPE, and moving them to a plugin.
However, there is currently a drawback to these: instead of working like libraries, these simply add the built-in library functions to the general function list. That means you do not have to call libmysql->mysql_connect but instead just write mysql_connect. I am not entirely sure this is how I feel that these plugins should be accessed.
However, it now means that creating ZPE plugins is now possible again.
My new transpiler for YASS to Python is coming along very well. After only about 3 hours of development, I have managed to get a program like this:
function doIt($x)
for($i = $x to 100)
print("Running in a function")
end for
end function
doIt(10)
for ($i = 0; $i < 2 * 3; 2)
print("Hello", "world")
end for
$z = 9
if($z > 10 || $z < 20)
print("Yes")
else
print("No")
end if
$x = 10 + 5 / 3
print($x)
To transpile to:
def doIt(x):
for i in range(x, 100):
print ("Running in a function")
doIt(10)
for i in range(0, 2 * 3, 2):
print ("Hello", "world")
z = 9
if z > 10 or z < 20:
print ("Yes")
else:
print("No")
x = 10 + 5 / 3
print (x)
This is the first big announcement related to this new transpiler, which will be available very soon at this rate.
