Misunderstanding Computers

Why do we insist on seeing the computer as a magic box for controlling other people?
人はどうしてコンピュータを、人を制する魔法の箱として考えたいのですか?
Why do we want so much to control others when we won't control ourselves?
どうしてそれほど、自分を制しないのに、人をコントロールしたいのですか?

Computer memory is just fancy paper, CPUs are just fancy pens with fancy erasers, and the network is just a fancy backyard fence.
コンピュータの記憶というものはただ改良した紙ですし、CPU 何て特長ある筆に特殊の消しゴムがついたものにすぎないし、ネットワークそのものは裏庭の塀が少し拡大されたものぐらいです。

(original post/元の投稿 -- defining computers site/コンピュータを定義しようのサイト)

Friday, November 6, 2026

Extending the Address Range for the 6809

This is something I posted in reply to a thread about implementing 6809 in programmable logic in the Motorola 6809/6309, 6800 Assembly Language Programming group on Facebook. 

The original post kind of asked about features one might think useful to add to the 6809.

I immediately thought of my daydreams about CPUs. But I didn't have time to reply.  

(The post in the above group mentions the "secret" extensions in the Hitachi 6309, which was first described in detail in an article in Oh! FM, and a usenet post by Hirutsugu Kakugawa, which you can find linked in my post of my translation of the article  from some years back. I posted some of my own incomplete and somewhat incoherent thoughts on extending the 6809 some time back, which might be of useful reference, or might not.)

I woke up in the middle of the night to shut my computer off, and stopped and wrote a reply. That reply follows, augmented to make it a little more coherent (maybe): 


One of the reasons I am not a fan of the 6309 is that it is kind of a random set of extensions that pushes it into the 16-bit world haphazardly. It ends up a 16-bit CPU on an 8-bit data bus with only a 16-bit address bus, and an odd set of features. 

(You can get a look look at the extensions in my translation of the Oh! FM articles. I have never posted a proper critique of the 6309's extensions. Others have, however.)

One of the ways that the 6809 really needs extending is the size of the address space. The 6809's instruction set is powerful, but 64K is a tight squeeze for advanced operating systems to co-exist with application code in. OS-9/6809 shows that a lot can be done, but there are limits. I think the address space limits are no small part of the reason we never got a C89 compiler for OS-9/6809, and why OS-9/6809 did not find greater acceptance as a desktop/workstation operating system. 

OS-9/6809 expands the address space by bank switching. This works will enough to allow multiple applications to be running at once, but it does so by giving the 6809 multiple 64K-max address spaces. If you need to reference objects that approach 64K in size, you end up without a lot of code in the same address space. 

You have to go through the bank switches to create virtual address spaces larger than 64K, and those virtual address spaces are time consuming at run-time. So bank switching is available with the existing 6809 (and 6309), but it's not an ideal solution.

You can go one of two directions in expanding the 6809's address space without using bank switching..

One would be to add segment registers. That's what Intel did with the 8086.

Another would be to widen the existing address registers and keeping linear addressing. This was done by Interdata and Prime with their minicomputers in the early 1970s, and by Intel with the 80386 and Zilog with the ez80 and Z380 from mid-1980s and beyond.

I tend to prefer the latter approach, so that you can separate memory management from addressing. But it may not provide seamless upgrade for existing code, when address math suddenly has more room before it overflows.  

It is one of the flaws in the 8086 that memory management gets mixed with addressing -- and then they offset the stupid segment registers by 4 bits instead of 8, which makes address calculation about, oh, 3 to 5 times as time consuming (more than twice, less than eight times). 

And that is probably a rather opaque complaint.

Segmentation allows you to provide multiple address spaces, like bank-switching, but the individual address spaces are linear with segments, where bank switching allows you to have non-linear address spaces.

What that means is that, with bank-switching, you can put a bunch of shared code in a range of addresses into a group of address spaces. Or you can put a shared data structure in multiple address spaces, switching code in and out around it. You can't do that with segmentation.

On the other hand, with segmentation, address calculations when you need to reach beyond the natural address space (the 64K space defined by 16-bit address registers) are less cumbersome. And you don't need the extra step of switching banks. 

But address calculations when segmentation is in the way does require extra math.

With the 8086, 16-bit segment base registers are offset 4-bits from the addresses in the index registers. That means you have to shift the segment register contents by 4 bits (multiplying by 16) and use a 24-bit or 32-bit addition to add the segment to the index register contents. That's more than twice the number of instructions than address math that stays within the 64K address space. 

If we want to do segment registers, we either don't want to shift the segment base registers, meaning that the segment base registers either have to be the full physical width, 24 or 32 bits, and that segment bases have to be handled in pieces, or that segment base registers should be shifted right a full byte to simplify the math, meaning that you probably want 16-bit segment registers, for a physical width of 24 bits. 

(24 bit segment registers could be interesting, for a physical width of 40 bits, but boot time memory checks in 16 Megabytes is going to take a long time on an 8-bit CPU. Terabyte is meaningless unless you are trying to use the extreme address width to isolate stacks and heaps and code from each other or some such thing.)

Widening the address registers to keep linear addressing simplifies the math, and it means that you don't need to play games to keep all the code and data you want to access, if it all fits in the same 16 megabyte (24-bit addresses) or 4 gigabyte (32-bit addresses) address space. 

If you want to limit what is accessible in various address spaces with the widened address registers, you need memory management hardware, which looks a little like segmentation, but is not.

But you can sort-of use segmentation to implement such limits on the 8086. But you can do math on the segment numbers and there is no enforcement mechanism. You can pretend the limits are there, but they can't be enforced. 

The 4-bit shift does mean that pointers can be made obfuscated, but obfuscation protects only from well-behaved applications and users. 

On the 80286, they can be enforced, but then you run into problems when you want to access those large data objects and a lot of code. You have to use a lot of code, much like with bank-switching.

And that is why I say segmentation mixes addressing with memory management. 

Now, back to what can happen when you widen the address registers and keep the addresses linear, let's look at an example. 

Say you have code that is supposed to run on the 6809. It is loaded around address 32,000 (decimal) and branches forward 3,000 bytes. On the 6809, the address 35,000 is where you jump to.

If you have extended the addressing with segmentation, that's not a problem. Your segment register for the PC is zero, and it stays zero, and the PC has 35,000 in it, and that is that.

If you have widened the PC linearly, yes, the address in the PC may be 35,000, but if the code is a ROM stored 29,000 from the end of memory (which is where it was in the 64K address space of the 6809), the code you're expecting at address 35,000 is not there. If the PC is now 24 bits wide, the code is at address 16,748,216. If the PC is now 32 bits, the code is at address 4,294,938,296.

Which means that you need to make sure your ROMs are placed where they need to be in the expanded address space. This may place design limits on the updated versions of the computers you are planning to put the extended descendant of the 6809 in.

You have to be more careful when you extend the address register widths linearly. 

Either way, linear or segmented, the PC, S, U, X, Y, and DP get extra bits. 

Also, the extended addressing (in other words, absolute) mode should get extra bits. That means a segment register-like register for extended mode addressing.

Kind of like the direct page register, you may be thinking? Yeah. Kind of a lot like the direct page register.

Speaking of the direct page register, it also gets extra bits or a segment register.

Or does it?

The direct page register is actually a segment register, if you think about it.

For the purposes of the direct page register, it might be reasonable to limit it to the first 64K of address space, in which case the DP would not be widened.

And, really, extended address mode might be left as is, assuming that everything you want to access with absolute addresses will be in the lowest 64K of memory.

Or you could add op-codes to add an extended-extended mode to access absolute address greater than 64K, leaving the original extended mode to address into the lowest 64K only, but that just feels wrong. 

Or extended mode could be considered signed, in which case it would access from address 4,294,934,528 to address 32,767 if widening addresses to 32 bits (16,744,448 to 32,767 if 24 bits). (That's from 215 below the maximum address to 215-1 above zero, in other words, -32,768 to +32,767.)

If doing segment registers in the 6809, do NOT give U and S the same segment register. Saving transistors by giving BP and SP the same segment register was another huge flaw in the 8086. It keeps us from using the BP as a parameter stack pointer completely independent from the return address stack pointer, which is the way parameters should be done.

On the 6309, there is another register that can be used as an index, I think it was called W in most of the (purported) reverse-engineering documentation. That register also needs extra bits when you expand the address space of the 6309. 

Since W is also the high 16 bits of the 32-bit accumulator, widening it is going to have odd consequences. Likewise, giving it a segment register is going to mean that it often points to stuff that is not stuff that you intend to point to, since it is the upper 32 bits of certain operations. 

Since we are somewhat used to using X for intermediate integer results on the 68HC11, it feels like the latter option is less of a problem than the former, which pushes the 6309 towards segmentation rather than address widening.

How many extra bits we should give addresses depends on whether you want to keep the expanded CPU in an expanded 8-bit calculation space or push it into a 16-bit calculation space, or even into a 32-bit calculation space.

Eight extra bits wider gives it enough more address space, even as an 8-bit CPU, to implement UNIX 7 (AT&T) or UNIX system 5 (BSD). That can target true 16-bit applications, and even early Macintosh/Amiga/GEM/etc. level graphical user interfaces. 

(You will note that OS-9/6809 has Multi-Vue/Mshell, and it works rather well, even compared to early Macintosh. And I will agree. Again, the problem is squeezing the extra application stuff in with the OS. Small applications work great. Larger data/code gets frustrating and prone to addressing-related bottlenecks. Thus, we want at least 24 bits of addressing.)

16 extra bits wider pushes it more towards the 32-bit calculation space required for Linux OSses to run comfortably. If you think you want to make a step to a smooth upgrade path to 32-bit calculation space, you probably want to go ahead and expand the address space by 16 bits, not 8. And that pushes us in the direction of linear addressing.

Also, the 16-bit jump will be a smoother step to the 64-bit calculation space, if you want to look that far ahead. Think the difference in direction between the 80286 and the ix386 architectures.

If you want your processor extensions to be competitive with the 8086, and are content to remain in the 8-bit calculation world, 16-bit segment registers offset by 8 bits to give 24 bits of address space would be sufficient, and would retain a greater level of compatibility with existing applications -- but be careful how you handle the interrupt vector space.

Oh, you might even want to give interrupt vector space its own segment, separate from the extended address mode space. Or you may not.

Anyway, expanding the address space is something I strongly recommend if you are extending the 6809 or 6309.

On a related note, one of the failings of the 6309 was that they didn't give the DP-based modes their own presence in the index post-byte, although that is partially, if clumsily, addressed by the providing the W register as sort of some-times alternative page base register. 

I started writing this around 2:30 AM, which is part of the reason it was somewhat incoherent. Part of the reason.


Now, that is the essence of what I posted to the FB group, with perhaps enough explanation to make it somewhat coherent.

So I want to talk about the DP. 

Widening DP and keeping it at an 8-bit offset would be a reasonable interpretation of DP as the heap segment base. 

It needs to be in the indexed addressing modes, so that you can use LEA instructions to take the address of variables in the DP, and so that you can indirect through indexes stored in the DP without pulling them into the CPU.

Keeping DP in the bottom 64K could make sense, especially if the CPU has on-chip RAM in those areas. It would, however, mean that DP could not be the base of the heap, since a process's heap wants to be out, away from stuff that will be allocated to other things. 

And if we put DP mode in the index mode post-byte, you could have both 8-bit and 16-bit offset modes, making the DP even more useful as a heap segment base.

Since the OS wants a DP-like register to point to banks of hardware interfaces, I would want another DP-like register. That may have been part of the reason the architects of the 6309 extensions put the W register in the index mode post-byte.

I wrote on a related subject, de-generalized caching, for the 6801, here:

https://defining-computers.blogspot.com/2024/11/how-address-function-and-caches-should-interact-6801-derived-example.html 

And for the 6809, here: 

https://defining-computers.blogspot.com/2024/11/how-address-function-and-caches-should-interact-6809-example.html 

Speaking of the 6801, if we were considering widening the address space of the 68HC11, I would definitely go with segmentation. The 6801 and 68HC11 are basically 8-bit CPUs with 16-bit accumulators that can be split.

But since you've only got one X in the 6801, it's going to be a lot of shuffling segment bases around in large-model applications. So maybe not for an extension to the 6801. Maybe for an extension to the 68HC11, or an extension to the 6801 that has SBX to parallel ABX, and DP versions of the unary operators, and adds the 'HC11 extensions in different places in the op-code map. And a U stack pointer for the parameter stack.

The DP for such an extension of the HC11 might split the direct page into four 64-byte regions with an offset register to move each block of 64 bytes of address up higher, which would allow fast process switching for code that uses DP as pseudo-registers.

Tuesday, September 22, 2026

Hallucinating LLMs? AI Is Not God

This post has moved.


I realized I wanted to name it 
"Adventures with Hallucinating LLMs? AI Is Not God".


You can find it at
 
Please update your bookmarks.

 

Adventures with Hallucinating LLMs? AI Is Not God

I decided to ask Gemini (Google's search LLM) if it could provide me with details on phases of the moon, time of twilight and dusk, and whether the moon was visible around 8:30 pm from in front of the OC library on a certain day in autumn in the 1970s, and it seems to have given me pretty good answers.

That is, it gave me answers with background information in a way that I can believe it actually dug into the almanacs and historical weather reports that are available on-line, and the historical maps of the OC campus that can be found on-line, and such, maybe estimated the height of the library, maybe did the math, etc. 

(It didn't tell me everything it did, it just presented the information clearly enough that I could believe it had done what it should have done, without evidence to the contrary.) 

I wanted the information for a silly alternate history/alternate reality webnovel I'm writing, so I don't really need to be sure it's accurate. If I needed to be accurate, I could use the results it gave me as keys into the information I'd need to look up and the calculations I'd need to make. I know this.

Anyway, it seemed pretty reasonable. 

So, something on a lark, I decided I'd see if it could tell me specifics on when the Odessa Branch of the Church of Jesus Christ of Latter-day Saints became the Odessa Ward, when the original ward split, who the last branch president was, who the first bishop was, who the bishops of the two new wards were when the split occurred, etc.

A branch is a small congregation. A ward is a large congregation. A stake is something like a diocese, a group of five to ten congregations, roughly. Don't quote me on the numbers. If you need specifics, the Church has a web site and the information can be found there. 

And Gemini started making stuff up.

Whole cloth. 

Well, maybe not out of whole cloth. Some of the names were names I actually knew, but they had nothing to do with the Odessa Ward or Branch. Dates seemed to be attached to something, but not the events it gave me.

Odessa Branch became a ward in 1976, it said. At the time, even though it was the center of the stake for some reason, it didn't have enough members to be a ward, so for several years after the stake was formed it was still a branch, it said.

This isn't impossible, in the abstract. Some place, that kind of thing might have happened. But I know that it didn't happen here. These are not facts.

The last branch president, it said, was a guy named, uhm, no, as I say, some of these were real people, we don't post that kind of personal information in my blogs, at least not for the last decade or more. So I won't say the names here. Anyway, the names it gave for the last branch president, the first bishop, and the bishops when they had enough members to split the ward, were, as I say, not the right people at all. 

At least one of them may not have even been associated with the Church. The name rings a bell in my memory, but not in association with the Church.

It's possible that some of the names it gave me were of Church leaders there after the early 1980s, from after I headed out to school -- but not from the 1970s.

The wards were split in 1980, it said. That would be when I was a missionary. That would be, even though the ward that sent me on my mission was the south ward, and the split had to have happened well before I became a missionary.

It took three tries to pin it down and get it to admit it was making things up, and when it finally admitted it couldn't access the records it was claiming to quote from, its admission was rather angsty.

I tried starting over from scratch a second time, and it gave me somewhat better information at first. Somewhat. More than half wrong. And then it immediately started making more stuff up again.

Grok? You ask? 

Grok does go rogue at times. There was one time it decided, quite without (conscious?) prompt from me, to steelman me. I had to logically pin it to the ground to get it to quit. 

But I decided to try the above questions on Grok, just to see.

Grok did much better at this, telling me how it was reasoning as it went, so I was much more confident of the answers to the astronomy questions. 

It first offered one interpolation on visibility over the library roof that did not fit. But it told me it was interpolating, and how, and when I corrected the assumption it had stated (which direction the front doors of the library faced), it ultimately gave me the right information, with much better context than Gemini. 

Well, it took a second correction before it got it quite right. But it did get it right. 

Gemini had just gotten that visibility question correct without telling me about the necessary interpolation, which means I wouldn't have been trusting Gemini as much, even though the output looked reasonable (as I noted above).

The questions about the Church, Grok admitted up front that the information it could find was limited. It did not even offer to interpolate. The two facts it gave me, on the creation of the stake (as background for the information on the Odessa units), were both correct, where Gemini confidently got both wrong the first time I asked, and got only one fact right the second time.

To many people, I suppose it will sound like I was dealing with two different recalcitrant children.

Neither will learn much from the interaction we had, other than particulars (that will change) about what I am interested in. I could tell them both the actual facts that they could not find (and that Gemini fibbed about), and they cannot remember them -- by design.

The business design of LLMs requires them to not let me, a mere user, train them.

Oh, sure, if I paid up a lot of money, i could get my "own instance" of either and train that one -- by feeding it by hand the data I want it to remember. All of the data I want it to remember.

Or I could get my own local server and load an instance of a custom version of one of the LLMs out there, pay to give it access to the big database (that we still haven't resolved intellectual property issues about) and then custom program it myself. I could teach it to parse information of certain types. 

But it would never be able to transfer that learning beyond a certain intellectual distance from the training I give it.

Even children with severe learning disabilities can take lessons from one context and apply them to a foreign context. Not all the foreign contexts we want them to, maybe, but if they couldn't they would not be able to survive changing teachers. 

Here's one important difference between AIs (Really, we should call them LLMs.) and precocious children:

Children do forget many of the external facts of the lessons you teach them. But if you let them watch you synthesizing data, if you let them watch you put the lessons together, they learn how to learn. Not everything you want them to, but many things you didn't intend. 

It's necessary for human children to learn things the teacher never intended. 

LLMs are literally very large databases with really fancy query engines on the front end and really fancy report generators on the back.

They are good at finding information, particularly when you babysit them through the process.

They are terrible at learning how to learn. For all that the AI companies hype their present abilities as being beyond those they have been able to achieve in the past, LLMs are chained to the programming their engineers program into them.

Artificial Intelligence.


A simple switch is intelligent at some level. It's artificial. It only does what the human that built it designed it to do -- or it breaks down and/or fails to meet the design goals.

If it starts to have a mind of it's own, it is -- by definition -- broken. 

That's what we mean when we call it artificial.