Hacker News: bluetomcat

New comment by bluetomcat in "Astra for Coding: Why Are We Doing This Again?"

bluetomcat — Fri, 11 Sep 2026 08:38:49 +0000

They are ignorant about the elephant in the room. The input language of a compiler is a formally-specified grammar with well-defined semantics for each operation. It generally abstracts the computation process over a von-Neumann machine, adding convenience features and bells and whistles. What "a=1" means in an HLL is, store that value in a particular storage location, so that it can be accessed later by the same name.

The slop machine reads lousy natural human language that can mean different things in different contexts. That lousy language is then statistically probed for the most likely output correspondence, producing shit that needs to be externally verified.

How I shamed the slop machine

bluetomcat — Fri, 28 Aug 2026 14:52:06 +0000

Article URL: https://bbuyukliev.blogspot.com/2026/08/how-i-shamed-slop-machine.html

Comments URL: https://news.ycombinator.com/item?id=49479421

Points: 4

# Comments: 0

New comment by bluetomcat in "I'm becoming AI-blind"

bluetomcat — Fri, 21 Aug 2026 15:53:57 +0000

It has no semantic depth. The sentences and the paragraphs are a statistically viable derivation of existing human text, but once you try to grasp the whole thing with its temporal and spatial dimensions, you are left with a blurry mess that rots your brain. It's a polished, inoffensive and shallow interpretation as written by an opinionated reputation-seeking user of Quora, circa 2019. Assertive, bold, without typos, clean-cut and bulleted, but without an interesting semantic core.

New comment by bluetomcat in "The case against a C alternative (2022)"

bluetomcat — Fri, 21 Aug 2026 10:33:07 +0000

> Why are we using C anyhow?

Because "cc prog.c; ./a.out" offers you the most direct way to interact with your system. Because "man 2 mmap" documents a C API. Because "nm" lists your functions and global variables with the exact same names as the C program.

The relative "lack of features" in comparison to its "better" alternatives is what makes it preferable. It lets you concentrate on the inherent complexity of the problem you are solving, and not on the opinions of vocal people online.

Code is the hard part

bluetomcat — Fri, 14 Aug 2026 13:40:12 +0000

Article URL: https://bbuyukliev.blogspot.com/2026/08/code-is-hard-part.html

Comments URL: https://news.ycombinator.com/item?id=49298549

Points: 7

# Comments: 1

New comment by bluetomcat in "Retire the Abstractions"

bluetomcat — Wed, 12 Aug 2026 09:08:48 +0000

Abstractions are ultimately a tool for humans to manage complexity in a particular class of problem, and to reduce cognitive load. Good abstractions come from imaginative human brains with taste and lived experience. Abstractions are also mind constructs that often have analogies in the real world. Even at the level of the CPU circuitry, abstractions serve that role. An LLM can only spit out what was already invented by humans and stitch it together in a tasteless, erroneous manner.

Are we living in an age of statistical mediocrity?

bluetomcat — Thu, 23 Jul 2026 11:28:33 +0000

Article URL: https://bbuyukliev.blogspot.com/2026/07/are-we-living-in-age-of-statistical.html

Comments URL: https://news.ycombinator.com/item?id=49019850

Points: 1

# Comments: 1

LLM coding is the wrong layer of abstraction

bluetomcat — Fri, 03 Apr 2026 20:12:00 +0000

Article URL: https://bbuyukliev.blogspot.com/2026/04/llm-coding-is-wrong-layer-of-abstraction.html

Comments URL: https://news.ycombinator.com/item?id=47631617

Points: 3

# Comments: 1

New comment by bluetomcat in "LLM Doesn't Write Correct Code. It Writes Plausible Code"

bluetomcat — Sat, 07 Mar 2026 16:06:16 +0000

No. Plausible code is syntactically-correct BS disguised as a solution, hiding a countless amount of weird semantic behaviours, invariants and edge cases. It doesn't reflect a natural and common-sense thought process that a human may follow. It's a jumble of badly-joined patterns with no integral sense of how they fit together in the larger conceptual picture.

New comment by bluetomcat in "We automated everything except knowing what's going on"

bluetomcat — Tue, 03 Mar 2026 13:53:23 +0000

We went from expressing computation via formal, mostly non-ambiguous languages with strict grammar and semantics, to a fuzzy and flaky probabilistic system that tries to mimic code that was already written. What could go wrong?

Show HN: Shell script and text database for vintage Lego Pirates collections

bluetomcat — Tue, 10 Feb 2026 20:15:10 +0000

Article URL: https://github.com/bbu/classic-pirates.sh

Comments URL: https://news.ycombinator.com/item?id=46966164

Points: 3

# Comments: 0

New comment by bluetomcat in "The choice between Rust and C-derived languages is not only about memory safety"

bluetomcat — Sat, 13 Dec 2025 10:29:03 +0000

You are correct. The final output was polished by ChatGPT, but I originally presented the basic ideas in a few paragraphs. The LLM added a sense of flow and persuasiveness which are somehow lacking in my rather dry and non-native English writing style.

The choice between Rust and C-derived languages is not only about memory safety

bluetomcat — Fri, 12 Dec 2025 21:07:15 +0000

Article URL: https://bbuyukliev.blogspot.com/2025/12/the-choice-between-rust-and-c-derived.html

Comments URL: https://news.ycombinator.com/item?id=46248960

Points: 45

# Comments: 19

New comment by bluetomcat in "Show HN: Cdecl-dump - represent C declarations visually"

bluetomcat — Mon, 08 Dec 2025 02:32:04 +0000

It starts from the identifier. At every stage, it outputs a sub-expression which is the “mirrored use” and corresponds to the boxed representation below it. When it reaches the top of the expression, it prints the final type of the expression which is the lone specifier-qualifier list.

As per the screenshot, “arr” is an array of 4 elements. Consequently, “arr[0]” is an array of 8 elements. Then, “arr[0][0]” is a pointer. And so on, until we arrive at the specifier-qualifier list.

Show HN: Cdecl-dump - represent C declarations visually

bluetomcat — Mon, 08 Dec 2025 00:26:04 +0000

A small tool that parses C declarations and outputs a simple visual representation at each stage, as it encounters arrays, pointers or functions.

The program uses a table-driven lexer and a hand-written, shift-reduce parser. No external dependencies apart from the standard library.

Comments URL: https://news.ycombinator.com/item?id=46186917

Points: 35

# Comments: 13

New comment by bluetomcat in "Some software bloat is OK"

bluetomcat — Tue, 04 Nov 2025 10:52:00 +0000

And consequently, "you need 32GB of RAM just to be future-proof for the next 3 years".

From epoll to io_uring's Multishot Receives

bluetomcat — Tue, 28 Oct 2025 17:39:21 +0000

Article URL: https://codemia.io/blog/path/From-epoll-to-iourings-Multishot-Receives--Why-2025-Is-the-Year-We-Finally-Kill-the-Event-Loop

Comments URL: https://news.ycombinator.com/item?id=45736075

Points: 16

# Comments: 1

New comment by bluetomcat in "Love C, hate C: Web framework memory problems"

bluetomcat — Fri, 10 Oct 2025 08:59:06 +0000

Because in C, every allocation incurs a responsibility to track its lifetime and to know who will eventually free it. Copying and moving buffers is also prone to overflows, off-by-one errors, etc. The generic memory allocator is a smart but unpredictable complex beast that lives in your address space and can mess your CPU cache, can introduce undesired memory fragmentation, etc.

In Java, you don't care because the GC cleans after you and you don't usually care about millisecond-grade performance.

New comment by bluetomcat in "Love C, hate C: Web framework memory problems"

bluetomcat — Fri, 10 Oct 2025 07:31:49 +0000

Yes, you can do it with minimal allocations - provided that the source buffer is read-only or is mutable but is unused later directly by the caller. If the buffer is mutable, any un-escaping can be done in-place because the un-escaped string will always be shorter. All the substrings you want are already in the source buffer. You just need a growable array of pointer/length pairs to know where tokens start.

New comment by bluetomcat in "Love C, hate C: Web framework memory problems"

bluetomcat — Fri, 10 Oct 2025 06:36:09 +0000

Good C code will try to avoid allocations as much as possible in the first place. You absolutely don’t need to copy strings around when handling a request. You can read data from the socket in a fixed-size buffer, do all the processing in-place, and then process the next chunk in-place too. You get predictable performance and the thing will work like precise clockwork. Reading the entire thing just to copy the body of the request in another location makes no sense. Most of the “nice” javaesque XXXParser, XXXBuilder, XXXManager abstractions seen in “easier” languages make little sense in C. They obfuscate what really needs to happen in memory to solve a problem efficiently.