HN Simulatornew | past | comments | lists | submit | 22c's commentslogin

First I'm hearing of TigerStyle.

> The time to solve performance, and get the 1000x wins, is in the design phase, when you can't profile.

How does this make practical sense? I find it immensely easier to fix performance issues by profiling, benchmarking, finding hotspots. Things that weren't obviously performance bottlenecks during design become obvious when you profile.

Interesting write-up though. I haven't properly tried zig but I like reading these "initial impressions" style articles about it.


If you understand how the CPU, memory, network, and disk are processing your program and its structures, you can design your programs to optimize for the hardware.

Full guide for ref: https://github.com/tigerbeetle/tigerbeetle/blob/main/docs/TI...


True. The guide is an interesting read. When you are deep in the trenches, most of what the github link says is just common sense.

Eg: < Optimize for the slowest resources first (network, disk, memory, CPU) in that order, after compensating for the frequency of usage, because faster resources may be used many times more. For example, a memory cache miss may be as expensive as a disk fsync, if it happens many times more.>

This is just obvious common sense. Great read.


> if you understand how the CPU, memory, network, and disk are processing

I don't think it's possible in the general case, it's way too complex for that. Sure for trivial examples it's trivial to claim one program is faster than the other, but can you really claim that your special allocator used in one place plus the extra argument used in calling that function is worth it without writing both options and measuring it? Like even measuring it is non-trivial, will it be inlined at the use site, how is it called, etc.


This is also true for garbage collected languages, JavaScript in my case, but it requires a custom profiler and a bit more digging while asking better questions.


You'll have a more direct path towards better performance if the questions you're asking are closer to "how does a CPU work", and further away from "what hoops do I have to jump through in 2026 to avoid optimization bailouts after V8's latest round of changes"


Yeah, except the CPUs are complex, you might not understand ALL the details of a working program (like randomising memory layout).

Plus not all speed-ups are made equal. Some speedups of a part of program can have no or even negative impact (as in making part of program faster slows down overall program execution).


No doubt, they are complex and you can't factor for everything, but I suspect that just even a cursory understanding of some broad characteristics across hardware will help you to design faster software when using a low-level language (and to some extent when using higher level languages as well), and your software will probably achieve must faster speeds than focusing on exotic design patterns in your software, for example.


The truth is really a middle ground and the fact that you won't get the design right the first time around until you have built that hardware programming experience and learned from past mistakes. But this statement doesn't make for a good marketing stunt.


Most undergrad CS students go through an algorithms course and understand a bubble sort is inherently slower than a quick sort, no amount of optimization will get you past the fundamental n^2 time complexity. You can generalize those same analysis principles to whole architectures and distributed systems. If you don’t recognize that the server interactions your solution requires boils down to an n^2 algorithm, you’re in for a bad time. Unlike a function a live, deployed system is typically harder to evolve. Sometimes constraints like backwards compatibility are such that you simply can’t fix it.


> Most undergrad CS students go through an algorithms course and understand a bubble sort is inherently slower than a quick sort

That sounds about right, a DS&A course which introduces Hoare's Quicksort, which is old enough to draw a pension, as if that's the state of the art.

Introspective sorting is more than a quarter of a century old and yet probably most people with a CS degree do not even know it exists. What a poor excuse for an engineering discipline this is.

Their big-O studies will lead them to conclude, as a Fortran textbook I've studied did almost forty years ago, that Heapsort is the right choice. Same big-O best case as Quicksort, easier to write but a better worst case. Of course the Fortran textbook does have the heart to mention that Heapsort is actually noticeably slower - but same big-O as if that's what your users will care about.

With a following wind and enough free time (or if they ask an LLM) they might come up with introspective sorting, putting them only a few decades behind the state of the art. Amazing.


While I don't agree TigerStyle inherently actually helps you with this, design and architectural mistakes don't usually get solved in the way you're describing. You sometimes have to rethink how to structure your entire codebase. Sometimes you can evolve an architectural improvement but sometimes it requires a complete rewrite and there's no way to get outside of that path dependency.


There's a different between fixing performance mistakes, which tend to be obvious in profiling as big hotspots, and designing for maximum performance, which requires that you start, really, with the specification of what your application is doing, then follow that through to architecture and design with a strong view to reducing unnecessary work and staying within the operations that can be done at high speed with current systems.


And Zig doesn’t seem to help with most of that!

If you’re already in your spec thinking about performance concerns at that level, then you can get pretty good performance in almost any language, though some languages might make it a little (lot) easier than others. But again I don’t think eg Zig vs Rust would be a big perf difference there.


Amazon has a history of fostering off-shoot companies that are given more freedom to innovate[1][2]. Keeping AI development in-house under Bedrock was probably their mistake. There's a big difference between running AI and developing new AI models.

[1] https://en.wikipedia.org/wiki/Annapurna_Labs

[2] https://en.wikipedia.org/wiki/Amazon_Lab126


I don't know where the Strands team sits in the org structure, but there's been a lot of stuff put out by them lately too.




I think we have to assume that the paraphrasing is at best a poor paraphrase and at worst completely misleading.

The paraphrased statement contains soft, non-deterministic hedges like "usually" and "sometimes", which would of course introduce uncertainty. Uncertainty -> low confidence.

The article strips out the actual prompt that went to Luna so we can't be sure they haven't ballsed the prompt just as they did with the paraphrase.

Compare the paraphrase to the language used in the actual paper they're trying to base their benchmark on:

> Bob is round.

> Alan is blue, rough and young.

> If someone is round then they are big.

> All rough people are green.

> Big people are not green.

This is obviously much easier to make certain statements about (the only thing we have to assume is that Bob and Alan are both "people").


> Alan is young, round, and kind, but that doesn't mean he isn't also rough and cold at times, as well.

What we learn: Alan is young, round, kind. These things don't prevent Alan from being cold or rough. Alan might or might not be "rough and cold" at times. It is not clear if Alan can be rough without being cold, or vice-versa.

> Young round people who are green are usually blue.

This tells us nothing about Alan. It tells us that young, round people can be both green and blue.

> Kind people with rough skin are usually red because it's wind burn.

Alan has been described as kind. We do not know if Alan is currently rough, we do not know if Alan has rough skin. Even if Alan had rough skin, we do not know if Alan is currently red.

> If someone shows that they are red, then they are also showing that they are green.

What does "showing" mean here? Either way if someone is "showing that they are red", then they also "showing that they are green", OK. I guess it also means that people can show that they are red and green.

> Statement: Alan is not blue.

Let's go through what we know about Alan.

Alan is young, round, and kind. Alan could at times be rough and cold.

That's all we know about Alan. We can't be certain that Alan is anything else.

Even if Alan were currently rough and being currently rough can be equated to "having rough skin", we still can't be sure if Alan is red as a result of said "rough skin" (only usually red).

Even if Alan is red as a result, we don't know if this counts as Alan is "showing" that they are red.

If we count Alan is red as "Alan is showing that they are red", then we can conclude that Alan is "showing" that they are both red and green.

If we count Alan is "showing that they are green" as "Alan is green", this STILL doesn't mean that the statemen "Alan is not blue" is false.

We do know (after we make ALL these assumptions) that Alan could be young, round, kind, rough/rough-skinned, (showing as) red/green..

So if someone is young, round and green, they are USUALLY blue.. THAT STILL DOESN'T MEAN THAT ALAN IS ACTUALLY BLUE.

Anyway, enjoy the free training data AI labs...


I think the statement is supposed to be clear despite the hedges because the statement itself is absolute, and we should assume that the info given is all info we have about Alan. So stating "XY is false" when we in fact know "XY could be true, we just don't know whether it is" is wrong.

If dogs are "usually wet", the statement "my neighbor's dog is not wet" is FALSE as long as we have no more information about your neighbor's dog.

Is that how it's meant? Struggling myself. But I think that would kind of make sense.

The statement "Alan is not blue" is not false because we know his color, it's false because we can't ascertain that he is NOT blue from the given information.

Similar category as "there is no teacup floating around Saturn" though, just with different hedges/probabilies? In that case, we'd lean "probably there is not such a cup", in this cryptic example, we are given clear indications equivalent to "teacups floating around Saturn have been observed before".

Yeah, I also can't make much sense of this.


Again, you need frame the article around the paper they're trying to build their benchmark against. Yes, the real world/natural language is fuzzy, but the ProofWriter paper (that this article bases it's own benchmark on) is not about taking fuzzy rules and turning them into proofs, it's about taking concrete statements, mapping those to facts, rules and conclusions.

We CAN'T from the statement "dogs are usually wet" make any conclusions about the wetness state of your neighbours dog.

We CAN from the statement "there is no teacup floating around Saturn" create a rule, specifically about teacups floating around Saturn.

As silly as that rule sounds, it allows you to refine/test against things, for example your space engineering team might have been under the assumption that no coffee mugs are orbiting Saturn, so you ask your all-knowing oracle what the probabilities of that statement being false are and you CAN get an answer that it rightfully doesn't know. That allows your space engineers to go back to the drawing board about the proof itself, is it actually that there's no crockery at all floating around Saturn? We can generalise our proof, then and cover off dinner plates and bowls as well instead of just tea cups.

The point is you don't _want_ the model to guess, in that scenario. You want it to say "I don't know, I don't have enough information to make that conclusion based on what you've told me about Saturn so far", which is exactly what Luna seems to do and get "wrong", according to the blog.


I'm not sure whether my guesswork was helpful, but I think the whole "probabilities" thing is not helpful here.

The teacups-floating-around-Saturn example was loosely copied from Bertrand Russell.

What my guesswork was aiming at was that my only meaningful interpretation of the example, taken as a riddle, with "free variables", was that the conclusion is wrong as in "not derivable from the given facts".

I agree in that I'd prefer to encode this as "I don't know".

But depending on how you interpret "false" and "true", the conclusion is false, and stating something as true that cannot be proven is false.

It's not very intuitive until applied to abstract terms instead of concrete ones, and I'm sure there's a fancy name for this higher-level logic.


Interesting, but didn't the folks from System One specifically say that Jev isn't really tuned for these kind of "Has the rest of the owl been drawn?"-style prompts?

For example:

> Non-obvious code lacks explanation of its rationale

This is so open-ended, I don't really think you're going to get reliable feedback from Jev here, at least according to my interpretation of what System One representatives were saying.


No it's not related, sadly Byuu passed away several years ago.


Sadly, the AI writing is so terribly distracting.

So the long and short of it seems to be an advertisement for the site itself?

I think this should've been a show HN as your affiliation with the site is not obvious from the outset.

Good luck with your project, but I suspect it will take more than a Claude subscription and a dream to replace what the article claims has been lost.


Guidelines | FAQ | Lists | API | Security | DMCA | Apply to YC | Contact

Search: