Last night was one of the most significant landslide victories ever achieved by a party in the UK's history. Although not as substantial as Blair's or Thatcher's victories, the fact that the Conservative party has dropped so low is awe-inspiring.
Below is an interactive graph showing the number of seats gained graphically:
And here is another one showing the share of the vote achieved by each party, and it's not quite as red as the previous graph:
I'm most impressed by Ed Davey, who has drawn me back to the Liberal Democrats again.
Strangely, this is the first time I've had a new UK government since I started to vote 14 years ago.
This is an exciting time in politics personally as this represents the first change in a long time. Keir Starmer seems like an honest guy (he'd have to be to have worked in law beforehand), and I feel he's the right person to do the job. The Lib Dems have recovered very well from this election, too, and I'm not surprised with Ed at the helm.
Starmer seems to care for all four parts of the country too:
We clearly on Thursday got a mandate from all four nations. For the first time in 20 plus years we have a majority in England, in Scotland and in Wales and that is a clear mandate to govern for all four corners of the United Kingdom and therefore I shall set off tomorrow to be in all four nations.
I usually come up with codenames for the next version of ZPE quite far in advance, and this year is no exception.
For version 1.13, the following codenames have been decided:
- Petergate
- Micklegate
- Davygate
- Castlegate
- Monkgate
- Goodramgate
- Fossgate
- Colliergate
- Gillygate
- Walmgate
- Coppergate
- Stonegate
The inspiration for these codenames came from the City of York, where I recently had a short break.
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.
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.
