jaen

Joined 16 years ago

Karma

382

Submissions

226

Member since

Jul 22

View on Hacker News

Recent submissions

Comment · 3 days ago

Doesn't really matter for H-Nets. These are Unicode bytes, as you said, so the nets can recover their structure (as demonstrated in the article!).

(I guess the training these could be somewhat more efficient if it was codepoints instead)

Comment · 4 days ago

Bytes are not used as tokens here and are in some sense an arbitrary choice (but they are a good one).

The article's approach just requires some indivisible base "atoms" to start the building the larger "tokens" from. (see: the DNA example)

It could be raw bits, but that's pointless, since dividing bytes into bits does not give the model any extra expressive power and requires 8× more computation. (yes, there's some structure at the bit level eg. lowercase/uppercase is represented as a bit in ASCII, but that's trivial to learn from just bytes at the scale the model operates)

Bytes are the ~best point on the expressivity/computation curve for this approach (for text).

(something else to ponder - why do bytes have 8 bits?)

Comment · 12 days ago

For those who might wonder, Blackfin is a CPU architecture with an assembly language thas has a more pseudo-codeish syntax [1]:

    R0 = R1 + R2

[1]: https://en.wikipedia.org/wiki/Blackfin#Core_features

Comment · 23 days ago

No point in hashing, it's trivial to infer the license plate from the hash since the space of license plate numbers is finitely small - one can just brute-force calculate a hash -> license plate table (also called a rainbow table).

Comment · 24 days ago

The project just exposes everything the hardware can do, the audio codec chip used for the conversion is Burr-Brown PCM3168A 24-Bit, 96-kHz/192-kHz, 6-In/8-Out.

Comment · 27 days ago

This seems to rebuild the entire view from scratch on every model update? Or is there some diffing magic that's not shown in the article?

This loses all non-persistent UI state such as scroll positions, half-entered text etc. etc.

Not really a workable architecture for a real app. React was invented because of this problem (how to make functional-style view building actually work...)

Comment · 1 month ago

Exactly the same thing also happened in 2020 with the Facebook SDK:

https://news.ycombinator.com/item?id=23097459

Comment · 1 month ago

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).

[1]: https://peps.python.org/pep-0827/

Comment · 1 month ago

Python has a strong, expressive static type system with a very fast type checker (Pyrefly).

Comment · 1 month ago

Fun times...

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.

Comment · 1 month ago

More detailed presentations about the Monaka CPU:

wccftech summary: https://wccftech.com/fujitsus-monaka-chip-3d-stacks-2nm-cpu-...

2026: https://global.fujitsu/-/media/Project/Fujitsu/Fujitsu-HQ/te...

2023: https://global.fujitsu/-/media/Project/Fujitsu/Fujitsu-HQ/te...

FugakuNEXT, the supercomputer it will be used in, also some details about the next-gen Monaka-X: https://global.fujitsu/-/media/Project/Fujitsu/Fujitsu-HQ/te...

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)

Comment · 1 month ago

Previous discussion of this on HN (2009): https://news.ycombinator.com/item?id=634692

Comment · 1 month ago

For anyone else wondering what Loom is, it's a concurrency permutation testing tool in Rust:

https://docs.rs/loom/latest/loom/

Comment · 1 month ago

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?