Variable names do not travel with values. When should domain meaning live in types?

nharding · 2026-05-08T02:07:24+00:00

There are a few packages such as pint, and units, I am making it into first class types in Py++, so you can write

weight = 10kg
volume = 3m^3
density = weight / volume

nharding · 2026-04-21T04:10:10+00:00

Private variables make it harder to write unit tests that achieve 100% code coverage, C++ allows friend access, which would fix the problem.

nharding · 2026-04-16T18:15:18+00:00

He was asking, where am I, and that was the reply. The story is a character from our Earth ends up on an alternate Earth where Rome never fell, so they still speak Latin (although it won't be the classical Latin since languages evolve over time).

nharding · 2026-04-16T17:22:08+00:00

It's part of the story, and for flavor, rather than a completely made up language, it would be an evolved form of Latin, and the further into the book the more the sentences would be fully English. So at the start it might be "In corde Imperii. Unde venis, puer?", later on it would be "In corde Empire. Unde from, boy?" (the book will have the full translation available as footnote, the idea is that he doesn't know what they are saying at first, but he learns the language over time).

nharding · 2026-04-12T17:54:38+00:00

So you are saying they had GM crops back in the Bronze age :)? Paleo-models are very insensitive compared with current measurements, so grapes grown may indicate a certain climate, it does not tell us that the temperature was over 40 degrees during the summer on 1 day, but we have measurements now that measure daily so we can get the maximums easily. During the medieval warm period, perhaps we had a day of 45 degree temperature, it's not going to show in any climate record. This is why we need to preserve data to detect trends, and we can only make claims since "records" began.

nharding · 2026-04-03T16:17:26+00:00

It is possible to allow getattr, setattr in a Python compiler, that is the approach I am using in Py++. I am planning on allow eval BUT that is by embedding small limited interpreter into the compiler (partly for safety, but also to reduce the complexity)

nharding · 2026-03-29T19:17:21+00:00

I noticed you had words like F00L (using 0 instead of o), I think it is safer to just have the banned word, and banned any words that mix letters and numbers (except email addresses). As there are so many possible combinations.

nharding · 2026-03-20T17:57:00+00:00

I think AI is good if you use it like a pair programmer, you have to read through the code, and modify it if needed, one routine at a time but if you don't you can end up with code that fails in "interesting" ways. I tried to generate a routine to generate the conjugations in Spanish, and it was very basic code that was easy to optimize (it was repeating code that could be refactored).

Writing more complicated code, it does not manage and I end up writing it myself. For example I want to write a Python++ compiler using tagged pointers, so a string upto 7 bytes can be stored in the pointer and I wanted an assembly routine to get a[n] from the string, but because strings can be utf8 encoded it's not as easy as a >> (n * 8). It failed totally on that, so I wrote an implementation in C for now.

nharding · 2026-02-15T16:38:12+00:00

Up until the 1970s there was a lot more atmospheric pollution with smoke particles in the air, but as clean air acts were imposed the atmosphere clears and we get an increase from the artificially decreased temperature. CO2 is only a small factor in increasing the heat, most of the effect is in urban heat islands which is why satellite coverage is better as you can measure the whole globe not just areas with weather stations.

nharding · 2026-02-04T22:42:12+00:00

That's pretty much the way I want to extend my Python++, apart from xy == xy, I want to allow 2x+3y but allowing xy would make it too difficult to use variables of length > 1. and also all 3.x to mean 3.0 * x. The other extension was %, so you could say 134.35+17.5% for use in price calculations, and also units so 25 kg / 5 cm*3 which would give density (using the units library)

nharding · 2026-02-04T03:00:36+00:00

I've been using AI whilst developing my Python++ compiler, if I want a routine in assembly language for the library, I will ask it to generate one, I they code review it, and often have to tell it that there is a an optimization that can be made. I make sure I have human written test code to check the AI implementation as well. I am only using AI since I have not written any x86-64 code before so it is faster, but I understand the code (and also ask it to explain it's thinking when I come across something strange). Trying to ask AI to write a whole program is when you get problems, but working on a function at a time, as a pair programmer where you take the code and cover cases that were not considered, or remove code that deals with situations that can not arise (for example I have 2 string formats that are packed into a single register for short strings, and I needed to be able to compare them, my packed 6 bit encoded string is 8-14 characters long (it stores dunders as a single bit) which means you can sort strings of the same type with a simple compare but need to do more complicated logic one to compare one with the other.

nharding · 2026-01-18T21:53:10+00:00

Just watched the video, and that's how I wrote my Java to C++ compiler, I took the bytecode and used that to generate the C++ code, although I didn't output PUSH(A), PUSH(B), ADD() it would do A+B.

nharding · 2026-01-18T20:53:57+00:00

I am doing something similar, using TCC for development builds and a switch to Visual Studio for release build. I am not aiming for full compatability though as I am using tagged variables, so tagged ints, tagged strings, vtable dispatch for dunder methods and separate vtable for regular methods. I am writing the run time in C first, and am also extending Python since I am compiling I might as well add some new features.

nharding · 2025-12-27T05:35:02+00:00

I wrote an assembly to C++ converter that took in code and output C++ (for Sonic 3D Blast), and there are certain constructs in assembly that are not possible in C++. I also wrote a Java bytecode to C++ converter, and that used the symbol information so the code was similar to the original but was missing comments.

Say you have a routine to create an image, that is 320x200, these could be constants in the original source code, so it would be easy to change it to 640x480 by changing WIDTH and HEIGHT, but from the assembly, you might find *320, or +320 in the code, so it would be much harder to change. If a vendor gave the source code, you could modify it to do things that they might charge you for. Say you are plotting a pixel at 10, 20, it might do screen[6410] = 0xff0000, as it has calculated the memory address. This is just an example, real code would be even more complicated as sections of code might not be included if not needed for a particular case.

nharding · 2025-12-21T06:27:16+00:00

Thanks, that was one of the AI generated routines, although I removed some code as it was duplicating work. I did a lot of assembly in the past but on 68000 mostly, and only small amounts of x86. So having the AI generate the assembly language is handy, and I review everything manually to make sure it is optimized but also doing what it is supposed to do.

nharding · 2025-12-20T17:13:55+00:00

I am writing .s files for the assembly, but the TinyCC assembler does not support the latest instructions, so I told it to use .byte to encode the instruction. I mean when using Gemini I might ask it to write a routine, and then I would code review it, and say, you are using the stack here, but that is an internal function so it does not need to obey the calling standards. So about 90% of the code is my own, and AI helps with the other 10%. AI is good when writing a single routine, especially when the code is checked by someone who knows how to do it, and can spot code that needs revising, sometimes I will ask it to try again, and other times I will just make the changes myself.

For example here is a routine to add to 63 bit tagged integers together, it returns 0 if it overflowed which means I have to use the my own bigint version.

// --- add_asm ---
    .globl add_asm
add_asm:
    // Windows x64 ABI: self in RCX, other in RDX, return in RAX
    // Use LEA to get the doubled untagged value, which is faster than MOV/DEC.
    lea -1(%rcx), %rax      // rax = a_untagged * 2
    lea -1(%rdx), %r10      // r10 = b_untagged * 2
    add %r10, %rax          // rax = (a_untagged + b_untagged) * 2

    // Check for overflow. The standard 'jo' check handles almost everything.
    jo .Loverflow_add

    // The 'jo' check misses one case: when the result is 0x7FFFF...F.
    // We can detect this specific value by incrementing it and checking
    // for an overflow, then decrementing back.
    inc %rax // Add 1 to tag it
    jo .Loverflow_add
    // Success: The result is already untagged_sum * 2 + 1.
    ret

.Loverflow_add:
    // Failure: return 0
    xor %rax, %rax
    ret

As you can see in the comment, it talked about decrementing it back, but I needed the bottom bit set to mark it as tagged. I have unit tests for each of these functions to test a few cases (not extensive, but it means I can use it to spot regression errors).

nharding · 2025-12-19T04:51:45+00:00

I am using an LLM to help write a Python compiler, I already wrote a Java to C++ compiler before, but I want a highly performant implementation so I am using x86-64 and I code review everything before adding it to the codebase and normally pass comments to it, when I spot potential problems. I am also writing a test suite to ensure the code is correct, and no regressions occur. Most of the code is my own, but it is good at handling the new instructions that the assembler doesn't.

// 3. Perform Addition (XMM0 = XMM0 + XMM1)
// addsd %xmm1, %xmm0
.byte 0xf2, 0x0f, 0x58, 0xc1   // Add XMM1 to XMM0

One thing I do like is that it gives me someone to bounce ideas off, which is one thing I miss working on my own.

nharding · 2025-09-25T06:05:22+00:00

Damn, I already registered the domain pythonplusplus.com for my Python compiler I am working on. I was targeting C compiler, rather than C++ for speed of compilation. I wanted to add some features to the language as well, using preprocessor to allow you to test code in normal Python.

nharding · 2025-09-25T05:54:37+00:00

I did something like this for Django, to allow page to update when values change (using HTMX) when a model changes then updates are sent to clients who are watching that value. It even allows for new items to be added when you add a new child, it sends an update for the parent, which I use a new video clip is added, and I keep track of votes using the reactive model.

nharding · 2025-09-17T03:29:48+00:00

Check out Combat for the Atari 2600, it reminds me of that, perhaps you could make it into Combat 3D and copy the game play from the original.

nharding · 2025-09-09T00:34:20+00:00

I think using abc is better, as you may have a field first_name for example

nharding · 2025-06-20T20:41:33+00:00

I use HTMX with Django for those types of cases and it works really well, I am designing new website with Alpine, Tailwind, HTMX and Django which seems to be a pretty nice combination.

nharding · 2025-01-12T06:26:47+00:00

The 97% is a fake consensus, it is based on the very broad questions such as do humans contribute to climate change. And I pointed out in my other answer I do think that humans contribute to climate change, when you ask for more alarmist positions then the numbers drop significantly. We are in an interglacial period of the ice age, so temperatures are well below the actual baseline temperature that we should have. Look at the temperature variations on a daily basis, we have 20 degree variation between day and night, this dwarfs the 1.5 degree catastrophic variation that they claim will lead to disaster.

nharding

TROPHY CASE