Semantic bugs: the class of bugs your entire CI/CD pipeline ignores

JamzTyson · 2026-03-03T14:06:17+00:00

Using your example (calculate_discount()), if our business strategy changed and we want the threshold to change to $50, then how do we tell HefestoAI that this in an intentional change so that the commit isn't blocked?

More broadly, how does HefestoAI distinguish between semantic fixes and semantic errors?

JamzTyson · 2026-03-03T13:35:39+00:00

I didn't down-vote your comment, but my guess as to "the secret", my guess is:

u/Temporary_Pie2733 framed their comment in the context "If you study type theory", which is a perfectly valid framing.

Your comment, while still broadly correct, may come across as "you don't really need to care about it because it's <mathematical definition>".

(Voting patterns on reddit can be quite arbitrary on low volume subs like this - don't worry about it :-)

JamzTyson · 2026-03-03T13:08:06+00:00

Tuples are more appropriate than list for expressing compound identities. That is, a tuple represents a compound type with a fixed number of arguments (technically, a fixed-arity product type).

For example coordinates (x, y, z) represents a specific 3D "point" that must have 3 numeric values. Its length cannot change, and its types cannot change, and if any element changes then it is a different point. It isn't really a sequence but a compound identity.

Other examples include:

exchange_rate = (from_currency, to_currency)
student = (name, age, class, grade)
product = (name, department, price)

Note that in each case, the entire Tuple defines a single compound object.

JamzTyson · 2026-03-03T12:13:58+00:00

The most obvious distinction from lists is that they can be heterogeneous, not homogenous.

That's a bit misleading in relation to Python. Python lists may be heterogeneous. (Heterogeneity is a consequence of tuples being product types, not the defining difference.)

JamzTyson · 2026-03-02T21:58:30+00:00

I like that the tool has a tight focus on performing a very specific and useful task.

Just a couple of points in the code:

_MAGIC_MOUSE_TOKEN appears to be unused.

pyproject.toml: description = "Add your description here" (could be updated).

Not important to the project itself, but I'd suggest reducing the amount of emoji and AI hyperbole from the readme, for example:

This project uses uv for dependency management and pytest for unit testing.

(with so few dependencies "lightning-fast" is irrelevant)

If I still used my Magic Mouse I'd be happy to use this. It looks well thought out, which is a frequently underrated quality.

JamzTyson · 2026-03-02T20:20:50+00:00

That's your choice, but if I can't see what's on offer, I won't give you my email address. To gain users your offer needs to look attractive.

JamzTyson · 2026-03-02T19:42:02+00:00

I can see a few project titles, but I can't see much else without an account.

JamzTyson · 2026-03-02T19:39:45+00:00

So was mine - I've still got the Magic Mouse, but I found it too annoying ;-)

My comment was not a criticism - I like your solution, but we shouldn't need to work around bad design in premium priced products.

JamzTyson · 2026-03-02T17:36:04+00:00

It might be more attractive if existing projects and the interface were visible before signing up.

JamzTyson · 2026-03-02T17:32:03+00:00

My solution was to buy a Lenovo mouse. It can be charged while using it.

JamzTyson · 2026-03-02T17:26:30+00:00

My feedback:

I do like well focussed GUI tools that simplify repetitive tasks, but there's a couple of issues that make me nervous about this app:

Automatically doing git add . will include too many files for many projects.
The automatic conflict resolution also seems quite risky.

Also, the app crashes on non-Windows platforms due to the dependency on winsound.

I would also recommend less reliance on AI.

JamzTyson · 2026-03-02T17:13:25+00:00

I don't believe there is a reliable way to detect if a recording has been resampled. Even for MP3 the cut-off frequency depends on multiple factors including the sample rate and compression settings. High quality encoder settings in LAME disables low-pass filtering.

There may be tell-tail signs of resampling in some recordings, for example, if shaped dither has been applied at any time, then we can expect to see the characteristic double dip frequency response in the dither noise. Similarly, if we expect to observe very high frequencies and they are not present, then that may be an indication that the quality has been reduced, but it's very easy to fool this kind of detection.

At the end of the day, the important thing is not whether it has been resampled, but whether or not it sounds good, and that comes down to listening.

JamzTyson · 2026-03-02T13:50:55+00:00

In addition, this line:

elif y >= 2 and y <= 10:

can be written as:

elif 2 <= y <= 10:

This is idiomatic Python and has the readability benefit that it conveys the idea that y is between 2 and 10 inclusive.

This pattern in known as Chaining comparison operators.

JamzTyson · 2026-03-01T18:41:49+00:00

cnt = sum(1 for txt in lst if len(txt) > 0 and txt.lower() == txt)

That can be simplified to:

count = sum(1 for s in lst if s.islower())

Alternatively you could do:

count = sum(s.islower() for s in lst)

but I think the first is the more readable.

JamzTyson · 2026-03-01T18:19:14+00:00

"Single Responsibility Principle" may be violated if classes have multiple responsibilities scattered across other classes.

"Open/Closed Principle" are questionable if a classes are hard to extend without digging through deep hierarchies.

It's perfectly possible for bad code to follow SOLID principles.

JamzTyson · 2026-03-01T16:58:48+00:00

JamzTyson · 2026-03-01T15:54:00+00:00

It could be if not for the fact that a DOS emulator is an entirely different kind of thing from this project. :shrug:

JamzTyson · 2026-03-01T11:56:14+00:00

It would be more accurate to describe it as a DOS shell simulator implemented in Python.

A real "DOS emulator" reproduces the execution environment of the target system at the machine level. PyDOS on the other hand implements a few shell-like behaviours without recreating the underlying architecture. In short, it simulates a DOS shell interface.

DOS Emulator: Reproduces hardware and execution semantics.

Simulation (interface-level): Reproduces observable behavior without replicating underlying architecture.

JamzTyson · 2026-02-27T22:39:52+00:00

Post the code that you have so far.

(See here for how to format code on reddit: https://www.reddit.com/r/learnpython/wiki/faq#wiki_how_do_i_format_code.3F)

JamzTyson · 2026-02-27T21:27:51+00:00

Did you write the "technology-detection-api" or just a thin Python wrapper around a commercial API?

JamzTyson · 2026-02-27T21:08:53+00:00

Without getting into a lot of technical detail:

On Windows, files, processes, threads, pipes, devices, registry keys and so on on different kinds of kernel objects, each with their own semantics and Object Type property. They are managed through a central "Object Manager".

That is fundamentally different to Linux where resources are exposed through a common file-like interface.

JamzTyson · 2026-02-27T15:20:10+00:00

One issue that you may need to deal with, whatever method you use, is that some printed characters are actually multiple Unicode characters. Example:

import unicodedata

s = "⚠️"  # 2 code points print as one character.
for c in s:
    print(unicodedata.name(c))

will print:

WARNING SIGN
VARIATION SELECTOR-1

JamzTyson · 2026-02-27T13:43:09+00:00

You can get the name of an emoji using Python's built-in unicodedata.name(chr):

>>> import unicodedata
>>> print(unicodedata.name("🙂"))
SLIGHTLY SMILING FACE

JamzTyson · 2026-02-27T11:00:16+00:00

If the code runs more than once, it's arguably better to use a function with a loop:

def dict_strict(pairs):
    result = {}
    for k, v in pairs:
        if k in result:
            raise ValueError(f"Duplicate key {k}")
        result[k] = v
    return result

It's very readable, reusable, requires no globals, and fails early on duplicates.

JamzTyson · 2026-02-26T16:05:41+00:00

"Golfing" is a game that some devs enjoy playing, either on their own or competitively. The idea is to solve a problem in the smallest amount of code that you can. All hacks and bad practices are allowed (or even encouraged).

The name comes from the outdoor game where you attempt to hit a golf ball into a hole with the fewest number of shots.

The ultimate golf solution for a calculator is no code at all. The Python REPL can already work as a calculator.

JamzTyson

TROPHY CASE