In this post, I’ll talk about the idea of “regions” of memory. These are the areas that zcode program data are stored in and can be accessed from. These regions are a key part of the Z-Machine memory map.
Continue reading Memory Regions in GrueBasics of Grue Memory
In this post, I’m going to continue discussing the memory that I began pulling information from in the previous post. Here the focus will be a bit more on the structure of the memory.
Continue reading Basics of Grue MemoryAccessing Memory in Grue
I need to talk about how to access memory so I can read values from it. And to do that I have to talk a little about a Z-Machine area of memory called the header. In this post, I’ll start getting information about a zcode program by reading the header stored in the memory of the zcode itself.
Continue reading Accessing Memory in GrueState in Grue
In the previous post in this series, I talked about the memory map of the Z-Machine. Here, I will get into a related topic involving the state of the Z-Machine. This will be a relatively short post to clarify what “state” means in this context.
Continue reading State in GrueMemory in Grue
In this post, I’ll dig into one of the core areas you must set up first for your Z-Machine implementation: memory. Without having the virtual machine’s memory set up, you can’t effectively do anything.
Continue reading Memory in GrueBits and Bytes in Grue
In this post, I will start down the path of implementing the basics of a Z-Machine. It’s crucial to understand how the Z-Machine works by how it takes in something called “zcode” to execute and precisely what is executing. Spoiler alert: it’s 0’s and 1’s all the way down.
Continue reading Bits and Bytes in GrueThe Ontology of Grue
In this post, I will start down the path of implementing the basics of a Z-Machine. The focus here is making sure there is understanding of exactly what a Z-Machine is, at a fundamental level.
Continue reading The Ontology of GrueSetting up the Grue
In this post, I’ll cover getting set up to develop the Grue Z-Machine implementation. By the end of this post, the goal is to have the start of a working project.
Continue reading Setting up the GrueContext for the Grue
In this post, I’ll give you an idea of how the Grue project is set up, which involves discussing the programming language and ecosystem to be used. This is the kind of information that, as a tester, I like to know. Indeed, these details matter for anyone looking to develop a Z-Machine implementation.
Continue reading Context for the GrueEaten By A Grue
For the duration, this blog will move in a slightly different direction than it has in the past. I’ll use this oddly titled post to explain what that means and why that is. By the end of the post, the title won’t seem so odd. And even if it still seems odd, it will at least be understandable.
Continue reading Eaten By A GrueScrutinize, Stabilize, Sustain
A lot of talk in the testing industry still focus on that divide between “automation” and “manual testing.” A lot of talk also focuses around how much and to what extent developers do testing. Here I want to provide a short post that indicates what I’ve done in my career, either as an individual contributor, a manager of teams, or a director.
Continue reading Scrutinize, Stabilize, SustainReframing Testing Arguments
I was giving a presentation to developers as well as engineering hiring managers who make decisions around hiring test practitioners. This came about regarding recent decisions in hiring, or rather, lack thereof. Brought up to me numerous times was the idea that testers are not being hired if they even hinted at the idea of testing as distinct from checking. So let’s talk about this. Continue reading Reframing Testing Arguments
The Social Dimension of Testing
I’ve talked in the past about my perception that specialist testers need to be cross-discipline associative. And while I’ve implicitly given some ideas about what that means in various posts, here I want to be a bit more explicit. Continue reading The Social Dimension of Testing
AI-Powered Testing: Exploring and Exploiting with Reinforcement
There’s a lot of talk out there about using large language models to help testers write tests, such as coming up with scenarios. There’s also talk out there about AI based tools actually doing the testing. Writing tests and executing tests are both a form of performing testing. So let’s talk about what this means in a human and an AI context. Continue reading AI-Powered Testing: Exploring and Exploiting with Reinforcement
What Actually Is Testing?
One thing that’s often interesting is to define foundational terms within your discipline. It’s often even more interesting when you come across a discipline that seems to struggle with doing so. Is that the case for testing? Well, let’s talk about it. Continue reading What Actually Is Testing?
My Role as Quality and Test Specialist
I often frame whatever role I’m in as a Quality and Test Specialist. It’s not really a term or phrase that our industry agrees upon. Normally people want the word “Engineer” somewhere in their title as if that term somehow wasn’t terribly vague. So let’s dig in to what I mean when I talk about being a specialist. Continue reading My Role as Quality and Test Specialist
Text Trek: Navigating Classifications, Part 6
In this final post of this series, we’ll look at training our learning model on our Emotions dataset. This post is the culmination of everything we’ve learned in the first three posts in this series and then implemented in the previous two posts in this series. So let’s dig in for the final stretch! Continue reading Text Trek: Navigating Classifications, Part 6
Text Trek: Navigating Classifications, Part 5
This post, and the following, will bring together everything we’ve learned in the previous four posts in this text classification series. Here we’re going to use the Emotions dataset we looked at in the last post and feed it to a model. Continue reading Text Trek: Navigating Classifications, Part 5
Text Trek: Navigating Classifications, Part 4
In this post, we’re going to look at the Emotions dataset that we briefly investigated in the previous post. Here we’re going to consider the basis of that dataset. Then we’ll load it up and see if what we have to do in order to feed the data to a training model. Continue reading Text Trek: Navigating Classifications, Part 4
Text Trek: Navigating Classifications, Part 3
In this post, we’ll explore some particular datasets. The focus here is just to get a feel for what can be presented to you and what’s available for you to use. We’ll do a little bit of code in this post to get you used to how to load a dataset. Continue reading Text Trek: Navigating Classifications, Part 3