HNHacker News
TopNewBestAskShowJobs

zephen

451 karma · joined November 29, 2025

submissionscomments
zephen··on Devtools must be open source
> I can see the allure of this line of thinking but I think it's sadly too idealistic.

I think it would be exhausting. Even if nothing broke, upstream UI changes could change your program daily. It makes a lot more sense for pulling changes that are security or bug fixes.

It seems like it would make sense for pulling enhanced functionality with no UI changes, but would you even use the enhanced functionality if you didn't even know it was there?

OTOH, I suppose if you organized your workstream correctly, you would always have previous binaries to fall back on.

zephen··on Devtools must be open source
> This sounds like hell. You have unreliable actor...

But, at least you know the cost up-front.

Oh, wait...

zephen··on Devtools must be open source
> which is absurd because forking should be a last resort for software that thrives from having a community.

This is true, of course, but having a community is completely orthogonal to whether software is open or closed source.

zephen··on Schmitt Trigger: Robust Comparator Design with Hysteresis
To be scrupulously fair, there are essentially two different ways to implement a Schmitt trigger.

One way involves feedback connected to the input pin. This inherently lowers the impedance of the input and that alone makes it less susceptible to noise, even before you consider the altered comparison threshold.

The other way, such as in a 74HC14, involves a very high impedance input, but the threshold the input is compared to is internally modified. Modifying the threshold also makes it less susceptible to noise, but the impedance is so high that it still might have some susceptibility, especially if it's, e.g. routed to a connector pin that might not be populated.

Your statement:

> The entire point of Schmitt triggers is to not switch back and forth constantly without a good reason.

is essentially true, and some Schmitt triggers, such as those on many CPLDs and FPGAs, work by repurposing pull-up/pull-down circuitry, but not all of them work that way.

Schmitt triggers, in the general case, are circuits that cope with slow rise/fall times and a bit of noise on the input pins, rather than circuits that properly cope with completely undriven inputs.

In fact, FPGA-style low-impedance Schmitt trigger inputs can wreak havoc on things like the I2C protocol, because you might be effectively altering the undriven impedance and voltage of the bus, so you might want to put a discrete Schmitt trigger inverter in front of the FPGA in some cases, or, if you have enough pins, perhaps use a differential input on the FPGA and a couple of resistors and a separate output pin to set the threshold.

zephen··on Schmitt Trigger: Robust Comparator Design with Hysteresis
> you'll want to ensure that any floating MCU pins

Stop right there. Floating CMOS inputs are generally not a good idea, even if they can be configured to shut off the digital receiver.

Yes, in some cases, you really can shut off the power to the digital receiver, but in the general case, you're better off configuring a pullup or pulldown on the pin, to keep it out of the CMOS transition region.

zephen··on Developers are attached to tools because tools encode trust
The term "xxx nazi" has been around for over 70 years to describe people with sticks shoved so far up their asses that they poke out the tops of their heads.

And "grammar nazi" has been around since at least 1990, and the infamous Seinfeld Soup Nazi since 1995.

I'm not sure of the etymology of the "not everybody's a Nazi Nazi" but I'm sure you're not the first.

But in any case:

> You can't just call everyone you don't like a Nazi.

Yes, yes, I can. I don't (because I reserve the appellation for certain particular kinds of attitudes), but I could if I wanted to.

zephen··on Developers are attached to tools because tools encode trust
> Apparently you just deserve a life of pain.

Don't we all?

(I can see that you are starting to get downvoted as well. Spread the love.)

Stack overflow was interesting. Its design was the only thing like it at the time, and made it a Schelling point for programming knowledge distribution, but also a welcoming environment for the programming equivalent of grammar nazis.

Some of those programming nazis, of course, had suffered at the hands of previous ones on stack overflow before becoming "enlightened." And thus, the generational hazing began.

It was great if google directed you to exactly the right answer, but god help you if you couldn't figure it out, and posed a question that someone thought didn't contain an MCVE.

Also, a few too many of the high-reputation people would post complete garbage on topics they knew absolutely nothing about.

zephen··on How old is Ann?
You're welcome.

> Just leave out the analysis of my mind!

I should have added weasel words like "maybe" and "probably" because I don't know you. Yet, everything I wrote, I have observed numerous times in other people.

And (and of course, maybe I'm wrong here) if you hadn't learned algebra, this solution would have been more obvious to you. Obviously we can't run that experiment directly. But think back to your childhood. Did you ever intuitively know the answer to a problem that others struggled with? Does that happen as often lately?

Formal methods like algebra are powerful and allow us to document, step by step, transformations that would be impossible to hold in our heads informally. We can solve problems that were unapproachable before. But we can get so used to using them that we forget intuitive tricks that we used to use.

Maybe this didn't happen to you. You're right. I don't know you. I'm only extrapolating. It really is the sort of simple problem that many people (possibly most of them younger) can solve immediately without assigning variable names or even writing anything down.

If this describes your capabilities when you were younger, then something changed. What is it?

Let me give you an example of my own. When I was a child I would play around with electronics. I intuitively knew that if I put two resistors in parallel, the amount of resistance would go down, and by how much, and could easily extend that to 3 or 4 resistors, rummaging through my collection to find resistors that would parallel to give me the value I wanted.

Once I learned the parallel resistor formula, I got slower at everything above two resistors.

Which brings us to:

> As you say, [using algebra to convert the problem to algebraic form] is impossible to do, because it doesn't make sense. So why bring it up?

I brought it up because, although we agree that it is not strictly part of algebra, it is something that you had to learn in order to use algebra effectively.

To me (and of course, again, I'm still speculating here) the fact that you're smart enough to use intuitive methods to set the problem up in algebraic form means that you were probably smart enough to use intuitive methods to simply solve the problem directly, if you weren't so used to directing your brain activity towards doing things using algebra.

zephen··on How old is Ann?
> Sorry to say, the first half of this comment is almost gibberish.

In what way?

> It became algebra when I introduced an unknown variable and wrote down an equation.

But a lot of people, including me, can solve it without writing down any equation.

> I can't see a way to solve the problem without doing that.

Ah. So it's gibberish because of your limitations? That's... not how this usually works. (Although, to be fair, it's often the case that people of limited intellectual means lash out with unkind comments such as "gibberish" so maybe this is how it works.)

> How did you get this equation from the problem statement?

"Mary is 24 years old. She is twice as old as Ann was when Mary was as old as Ann is now. How old is Ann?"

We know that there is a delta between Mary's current age (24) and what I called X in my previous comment (Ann's current age AKA Mary's prior age). That would be 24 - X.

We also know that at some previous time, Ann was 12 (half of 24) when Mary was (Ann's current age AKA Mary's prior age).

Some of us just take the mental shortcut that the in between age has to be the average of 24 and 12 (because the delta doesn't change[1], so the delta must have been the same before as it is now), but if forced to write it down into algebra, we can say that this second statement is X - 12.

And then of course, again, because the delta doesn't change, and the delta is equal to both x-12 and 24-x, those expressions must be equal to each other.

[1] Except of course, the delta could wobble a bit for birthdays being on different dates within the year. In simple puzzles like this, of course, that +/- 1 year possibility is usually ignored.

zephen··on How Old Is Ann?
> It's a kind of cheating because it means not understanding the essence of the problem

In my opinion, this method presumes a clear understanding of the problem itself.

If you didn't have a clear understanding of the problem, you would not be able to test an answer to see if it is correct.

Now, this clear understanding of the problem could, of course, be coupled with a lack of understanding of other methods available (such as algebra) to solve the problem.

OTOH, maybe it's just coupled with a clear understanding that with the working memory that you have available to you right at the moment and without writing anything down, you don't even need those other methods.

zephen··on How old is Ann?
Thanks for the downvote.

Look, when someone says "you need algebra to solve this" is it reasonable to assume that they are talking about informal methods that people have used forever, or is it more reasonable to assume they are talking about formal algebraic methods?

Because many people sure as shit don't need any algebraic symbols or operators to solve this in their heads.

zephen··on How old is Ann?
But that was over a hundred years ago. She must be dead by now.
zephen··on How old is Ann?
> I can't see a way to do it without algebra.

This is related to "When all you have is a hammer, everything looks like a nail."

It's slightly different, because you've supercharged your hammer. Everything you ever understood about how to solve word problems has been subsumed into what your brain labels as "algebra."

But look at it this way:

1) Did you use algebra to convert the problem to algebraic form? Probably not; algebra says nothing about word problems.

2) Once it was in algebraic form, did you need to repeatedly apply algebraic rules in order to reduce the problem, or could you glance at it and figure it out?

You may also be hampered by your choice of variable, because you chose "X" to be an intermediate variable.

If, instead, you choose "X" to be what you are searching for, Ann's current age, then the problem setup is:

  24 - x = x - 12
Which many of us can solve in our heads without writing down, or even without consciously converting "Ann's current age" to "X".
zephen··on Our position on open-weights models
Do you have a citation that shows that this issue has been settled?
zephen··on Uhubctl – control USB power per-port on smart USB hubs
I did a similar thing with a rack of test equipment. I had a PC power supply on each shelf, and used an NPN transistor to turn on the power supply whenever the USB port connected from the main computer to that shelf rack was turned on. Crude, but effective, out of band communication.

The local USB hub on the shelf was powered from the PC power supply on that shelf, so a single long USB cable from the shelf with the control computer could command the shelf (including the USB hub on the shelf) to fully power up or down, and then control several test devices through the USB hub, and none of the USB devices on the shelf (some of which were bus-powered) needed to worry about not getting sufficient voltage through a long cable and a hub.

zephen··on Uhubctl – Control USB power per-port on smart USB hubs
These are what I use: https://www.amazon.com/dp/B096YKDYX5

However, to your point:

> I think especially the cheap hubs will changes the parts used overtime and not update the revision.

Yeah, the last time I purchased them was December 2022, so I definitely don't know for sure that they still work. But they aren't the cheapest hub, so maybe?

But at that time, I purchased hubs from several manufacturers, and most of them didn't work. The first thing I had working was actually an eval kit from an IC vendor.

Also, many hubs that can theoretically be used powered or unpowered are terrible about backfeeding power, either to the host, or (more commonly) to the wall wart.

It's best to either always use the hub unpowered, or to buy a hub that always requires power, unless you've checked and made sure that it's not going to screw you over.

zephen··on How to pack ternary numbers in 8-bit bytes
I agree.

But then, I'm pretty sure you haven't said anything different than what I said in the great-great-grandparent of your comment, other than slightly fleshing it out for a couple of particular scenarios.

But you haven't covered the packing, which is the primary thing I was suggesting you might need multiple tables for if you really wanted to use tables and really didn't want to do shifting or multiplication.

zephen··on Perfection is not over-engineering
You need to be careful with this one, or reductio ad absurdum might lead you to not build microservices, or even a monolithic app, before you have acquired your first customer.
zephen··on How to pack ternary numbers in 8-bit bytes
There are 5 trits.

In any case, if there were 3 trits, I'm not sure what the practical difference between a single table you describe and 3 different 256 byte tables, again depending on the architecture.

Yes a single table would have better cache effects for a single read, but presumably? you're doing a lot of reads in an unpacking phase.

zephen··on How to pack ternary numbers in 8-bit bytes
I was wondering the same thing.

Obviously, it partly depends on the implementation machine, how big a hole the tables blow in your cache, how fast the multiplies are, etc.

But it probably also hugely depends on the format that you want your trits in. If you use them unpacked, e.g. one trit per byte, then even if you're using tables, you still have to do a lot of manipulation (e.g. either shifting and oring, or having different tables, and a table lookup per trit and adding together to get the binary).

zephen··on The Tower Keeps Rising
Attention is a valuable commodity. I guess I owe you. Here, have an upvote.
zephen··on The Tower Keeps Rising
What's the point? There's nobody here but you and me.
zephen··on The Tower Keeps Rising
> I can guarantee you that most of these simply didn't go far enough;

And I can guarantee that I knew, when I wrote my comment, that I was summoning this very "No true Scotsman" argument.

> they couldn't work out how far a canon ball will land fired at a 45 degree angle with a certain velocity, though they can crack jokes about Schrödinger's cat.

It always superciliously starts with how true lisp people are the most brilliant ever.

> Then once you start grappling with the Lisp issues, and kick the rock farther down the road, even in some small way, you are invested.

And is eventually undermined by an admission of cognitive inflexibility, although not usually so quickly or in the same comment. Good job!

zephen··on The Tower Keeps Rising
> For me, the answer to this is economics. Even if you love lisp, there are way more companies hiring for stacks that don’t include lisp

Certainly. But why would that be? It couldn't possibly be that the programmers already there built a system using the tools of their choice, and that system is now running well and deemed maintainable enough they require additional developers for the same language, could it?

Sometimes, of course, companies change their implementation language. The most famous cases I know of this are Viaweb and reddit, where the companies moved away from lisp. The company's main motive in this, of course, is making money. If they have a good product that is deemed maintainable, why would they piss off the original team, who probably chose the language, by switching languages?

Many programmers have worked in lisp. Studies have shown that programmers routinely learn new languages and somewhat forget old ones; older programmers are typically only currently proficient in as many languages as younger ones.

A company with a successful product is going to attempt to leverage that success. Whether leveraging it looks like incrementally improving it, or like treating it as a prototype and throw it out, will typically be a long conversation between developers and management. Typically incremental improvements are greatly preferred; it is only when all stakeholders become convinced that a fresh start is required that massive changes like implementation language will take place.

The calculus, of course is changing with LLMs. See, for example, the recent migration of bun away from zig. That rewrite was spearheaded by a massively effective lone developer, the exact persona that is claimed to always prefer lisp. Sadly, he chose rust.

zephen··on The Tower Keeps Rising
> compared to languages which demand much more effort to get anything substantial done.

It is not clear at all to me that other languages "demand much more effort" for the same end result.

It is clear that many non-lisp programmers value syntax, and many lisp programmers don't. Even many people who programmed enough lisp to have their minds blown and expanded still prefer not to program in lisp. I'm still awaiting psychological studies on this, but the rift is so large, I think there may be some significantly different brain processing going on between the two groups.

To your point, yes, it is also clear that, to the extent that lisp can match the productivity of other languages, whether it exceeds them or not, one of the tools that is needed to achieve this productivity boost in lisp is heavy usage of homoiconicity, and this results in every serious lisp program being a collection of DSLs, each of which is only understood by one person or very few people.

zephen··on GitLost: We Tricked GitHub's AI Agent into Leaking Private Repos
I cannot disagree, but many who should know better do.

I have seen people argue with a straight face that there are no copyright concerns simply because of the sheer volume of the data that LLMs are trained on.

This makes less than zero sense. If someone has seen code, or heard music, and creates something too similar, it is a copyright violation, even though that person has seen much code or heard much music before. This is why the concept of "clean room" implementation exists, and why the concept of the abstraction-filtration-comparison legal text exists.

LLM proponents will point to the fact that courts have ruled that using copyrighted material for training has been ruled fair use.

This actually makes sense. Just as you can read a book, so can an LLM.

The thing that, AFAIK, hasn't been ruled on yet, is when the LLM regurgitates something that is too close to the book. If a human were to do that it is a clear copyright violation.

To pretend that "dilution is the solution to pollution" in terms of LLM training data, and that anything the LLM produces is original material, is to give LLMs more rights than humans have.

zephen··on Small Penis Rule
> I wonder.

I didn't, and still don't, but now I wonder why you wonder.

zephen··on Small Penis Rule
Yes, I see you have produced a very small (re)tort, but arguably have used it well.
zephen··on We Are the Last People Who Know How It Works
It's kind of a useful distinction, but the categories are really blurry.

For example, the layout software vendors provide a solution that both uses non-determinism in their final product, and also checks the results against whatever criteria you give it.

If it tells you it will work, it's probably not lying, and if it tells you it won't work, it's almost certainly not lying.

So in your own creative process of building a board, you can rely on that.

Many LLMs don't have this property at all, and honestly, it really doesn't matter whether you are using the LLM to craft a legal document or to craft code; if you don't check the output yourself, you're possibly in for a world of hurt.

> Now if you are "running" your "generated code" that's where people will have strong opinions because it conflates the two completely different processes in the worst way possible.

I think a primary driver of the attractive nuisance here is that, because the execution of the resultant code is itself a deterministic process (even if the process that produced that code it isn't) people think that they can tame the process, by some combination of automated testing and looped automated reprompting.

At some level, they may not be wrong -- computer chips themselves are built on top of stochastic atomic processes, and google famously proved in its early days that it could have reliable processes on top of shitty commodity hardware.

But one key difference is that the nondeterminism in the atomic processes or in the non-ECC memory of the white box computers is uncorrelated.

And another key difference is that, unlike the layout software vendors, so far the LLM vendors seem unable or unwilling to properly self-check their own outputs.

To me, this is kind of the canary in the coal mine. You would think that the LLM vendors have every incentive to weed out bad results, that they, more than anybody else, have the understanding of root causes and probabilities that a particular output might be bad, and have more than sufficient resources to fix this, if it's not an intractable problem.

So Occam's Razor says that (currently) this is still an intractable problem.

zephen··on We Are the Last People Who Know How It Works
> I would say [whether nondeterminism is bad] is unambiguously defined by the problem you're solving.

Sure. You gave an example where it can work. Another example is something like a PCB or chip layout engine.

That particular domain (layout) is NP-complete. You'll never have an exhaustive brute force search for the optimal layout, but...

You can subsequently easily check whether the produced layout meets all your acceptance criteria or not.

Another example that successfully utilizes non-determinism for good outcomes is the application of genetic algorithms to things like antenna design.

This works because (a) you have a relatively cheap fitness test; and (b) as with real evolution, the mix of combining working designs and randomly introducing mutations often eventually produces outstanding results.

Presumably, if you applied genetic algorithm techniques to, e.g., creating your LLM prompts, you could also get good results, but that would probably quickly get expensive in terms of tokens.

So we're left with people just semi-randomly modifying prompts in order to try to tweak results.

When it works, it can be amazing. When it doesn't work, it's like a brick wall.

I like your "embarrassingly nondeterministic" term, but I somewhat disagree with:

> A "bug" then would be considered "weak accuracy" not "crash" or "incorrect behavior",

When a lawyer asks an LLM for citations of cases that support his position, he is arguably doing something stupid, because embedding an assertion such as "Show me cases which support X" is just asking for hallucinatory trouble with many current LLMs.

Nonetheless, I submit that hallucinations are, by definition, "incorrect behavior" and not merely "weak accuracy."

Now, nondeterminism could certainly be useful to the lawyer, in that it could help an LLM make connections that LexisNexis might not have in their database. So asking an LLM for help with legal issues is theoretically not an insane thing to do, but the results need to be checked very carefully.

← PreviousPage 3 of 19Next →