I love python for some stuff, but i definitely would not say it has an expressive type system. Enums are a second-class citizen, and typed dicts are definitely not as convenient as i would like. And to my knowledge, type checkers don't support proper exception catching rules; rust also has no guarantee that a function won't panic, but usage of Result type makes it less of a problem (because panic is more or less exclusively for unrecoverable invariant violations), and there's ecosystem tools to make sure you don't ever panic.
If by enums you mean sum-type ADTs (like in Rust), then Python is certainly quite expressive - it has union types, which can represent polymorphic variants - those are slightly more expressive than pure Rust-style ADTs since you can arbitrarily subset or extend the enum cases.
@dataclass @final class CaseA[T]:
field: T
type MyEnum[T] = CaseA[T] | CaseB
This also gets exhaustiveness checking in `match` statements (depending on the type checker). Overall, enums have a similar style to Scala and Java >=21 (mixing OO + ADT). I guess syntactically it can be slightly verbose depending on the exact situation...
I wouldn't call them second class, but yeah, not a lot of existing libraries use this style.
Typed dicts (with the latest PEPs) are an improvement over any other language besides TypeScript. Yes, in TS, certainly `Partial` / `Pick` / `Omit` and intersection types make modeling the web API swamp easier, and that's one place TS is superior to anything else.
Python does have the Type Manipulation PEP 827 [1] out to give it similar powers to TS, but I feel that's unlikely to be implemented soon / as-is.
Having an effect system for exceptions would be nice indeed. That's actually something I'm looking into (having an "allowed exceptions" annotation for functions and then checking it at test-time via failure injection and possibly in type checkers).
This is before the DOM Canvas 2D API existed, so effects like digging are implemented by overlaying multiple 1px-high black GIF <img> tags over the background.
For a single CPU:
844 GB/s memory bandwidth (12 channels of DDR5 RDIMM, 8800MT/s). 4.3-6 TFLOPS.
Basically comparable to a modern (although not top-end) GPU, so good for HPC & AI workloads. (though only 2 CPUs per node, with GPUs 4-8 is more common)
For anyone not familiar with Fujitsu's CPUs, worth noting their overall long history with HPC, and more recently, ARM. FugakuNEXT is "NEXT" because the current Fugaku (#1 on TOP500 for a time, and still in the top 10) also used an ARM CPU from Fujitsu.
Benchmarks will be interesting to see but I doubt the cores alone will be able to reach beyond ~500GB/s of BW, and even if they match that figure it will be great.
Man this looks amazing, more competition is always welcome! The issue for Ai inference is always firmware/software support. Up until recently, that rocm hardware became usable, let alone optimized. Nvidia had a big start, now everyone is trying to catch up
You're just offering non-helpful ivory tower criticism without even understanding the problem space (which is actually one of the hardest open research problems in software engineering, cs.PL + formal methods).
But if I'm wrong, dare say, how would you write a production memory-safe JIT compiler today?
If I couldn't guarantee memory safety, I wouldn't. We're talking about an optional feature for JavaScript engines.
Security is where the rubber hits the road. It's whether customers' identities get stolen. It's whether leaders of undemocratic countries can monitor communications, locations, and social networks of people whom they oppress.
Calling this an "ivory tower" criticism is, ironically, a lack of acknowledgement of reality and that our actions have consequences to others.
This is only applicable to die photographs of the silicon layer.
For CT scans, which use X-rays, the visible structure is very likely due to the metallic (copper) interconnect, clock- and power-delivery layers, which are generally quite different from the underlying transistors.
These layers are larger-scale, and copper also absorbs X-rays much more strongly than silicon.
I think you overestimate the amount of senior engineers... even at the extreme end of top-tier big tech, only around 30% can be considered senior. Staff engineers who regularly think at the level GP talks about are 5-10%.
Everywhere else the percentages are quite a bit lower still (if judged by the same standards).
Ya I was very hand wavy. Though in my experience a lot of smaller shops have a higher percent of seniors than big tech. And I don’t know how much smaller shops there are, so I rounded up. Also smaller shops depend more on this well rounded thinking.
No... Adaptive sampling is a family of statistical methods to choose an appropriate decimation strategy for arbitrary events based on real-world occurrence distributions.
It can be applied to tracing, metrics, logging ("sampling") and profiling.
Trick: it's easy to check this - just try eg. a specific short almost-nonsense high-entropy phrase such as "Scarf Color Plump 蘼撅" via OpenRouter using the playground for different providers/models, and observe the shape and language of the reasoning and the response, which tend to be quite different (MiMo and GLM are quite similar, but still identifiably different enough).
reply