HNHacker News
TopNewBestAskShowJobs

lgrapenthin

386 karma · joined July 28, 2015

submissionscomments
lgrapenthin··on I passionately hate hype, especially the AI hype
Sorry, these claims are just not true. AI generations in these categories are impressive on release, but blatantly generic, recognizable, predictable and boring after I have seen about 100 or so. Also, if you want to put them to use to replace "real work" outside of the ordinary/pretrained, you hit limitations quickly.

The scaling laws of the Internet were clear from the start.

lgrapenthin··on I passionately hate hype, especially the AI hype
Your example is a better search engine. The AI hype however is the promise that it will be smarter (not just more knowledgeable) than humans and replace all jobs.

And it isn't on the way there. Just today, a leading state of the art model, that supposedly passed all the most difficult math entry exams and whatever they "benchmark", reasoned with the assumption of "60 days in January". It would simply assume that and draw conclusions, as if that were normal. It also wasn't able to corrrectly fill out all possible scores in a two player game with four moves and three rules, that I made up. It would get them wrong over and over.

lgrapenthin··on The program is the database is the interface
Was this written by a LLM?
lgrapenthin··on All Lisp indentation schemes are ugly
> Once you get used to Lisp, you stop noticing the parentheses and rely on indentation instead.

Who does that? LISP has a datastructured syntax, textformat has no meaning in it.

lgrapenthin··on Tabby: Self-hosted AI coding assistant
Such interview processes are big red flags. The company can't afford taking a risk with you and at the same time tests how desperate you are by making you work for free. They are likely short on cash and short on experience. Expect crunch and bad management. Run.
lgrapenthin··on All clocks are 30 seconds late
So they ignore minutes entirely and just live in hours?
lgrapenthin··on On the nature of computing science (1984)
Separation of concerns is the false promise of all these so-called "architecture patterns." Their advocates make you believe that their architecture will magically enable separation of concerns. They offer blunt knives to make rough slices, and these slices always fail at isolating relational concerns, inviting entirely new layers of complexity.

You had a relational database, designed to store and query a relationship between a user and their orders. Now, you have a user management service and an order service, each wrapping its own database. You had a query language. Now, you have two REST APIs. Instead of just dealing with relational problems, you now face external relation problems spread across your entire system. Suddenly, you introduce an event bus, opening the gates to chaos. All this resulting madness was originally sold to you with the words, "the services talk to each other."

Who ever claimed that REST services compose well? Because they can "talk to each other"? Really? Only completely disconnected architects could come up with such an idea. REST services don’t compose well at all. There aren’t even any formal composition rules. Instead, composing two REST services requires a ton of error-prone programming work. A REST service is the worst abstraction possible because it’s never abstract—it’s just an API to something extremely concrete. It doesn’t compose with anything.

Microservices aren’t micro. They’re hundreds of large factories, each containing just one small machine. Inputs need to be packaged and delivered between different factories in different locations, adding complexity every step of the way. This is what happens when enterprise architects "rediscover" programming—but from such a disconnected level that the smallest unit of composition becomes a REST API. Rather than solving problems, they create a far larger problem space in which they can "be useful," like debating whether a new microservice should be created for a given problem, and so on.

The same critique applies to "hexagonal architecture." In the end, with all of these patterns, you don’t get separation of concerns. The smallest unit of the architecture was supposed to be the isolation level where your typical problems could be addressed. But your problems are always distributed across many such units, making them harder to solve, not easier. It’s a scam. The truth is, separation of concerns is hard, and there’s no magical, one-size-fits-all tool to achieve it. It requires significant abstraction work on a specific, concrete problem to slice it into pieces that actually compose well in a useful and maintainable way.

lgrapenthin··on What we know about CEO shooting suspect
Could as well have walked into a police station or uploaded the manifesto on his GitHub.
lgrapenthin··on The Meaning of Bitcoin
Cars were sold/bought for BTC and ETH when the war came to central Ukraine, nobody went to prison for that. Many people there do transactions daily via TRON chain nowadays.
lgrapenthin··on The Meaning of Bitcoin
There is a multitude of governments involved in Bitcoin with different incentives and strategies. If you claim "The government can do X to Bitcoin" you should explain which government(s) and how exactly that would work. When was the FED a "democratically elected government", by the way?
lgrapenthin··on Try Clojure
Do they have a realistic shot at implementing immutable datastructures?
lgrapenthin··on A Road to Common Lisp (2018)
What most answers here are missing is pointing out the unique difference between a LISP REPL and an interpreter console/shell kind of thing, which is that it fits seamlessly into the languages design. I often see Javascript devs quite unimpressed by a REPL - "I have a console, too". And while Javascript admittedly comes close, its just not the same.

What makes LISP REPLS special is precisely that there is nothing special about them.

There are no extra ceremonies, caveats, or layers that turn a LISP into a REPL. Its conceptually a fourliner, merely replacing the compilers input of parsing text files with reading user input, while providing access to a modified environment after each step. This is possible not because of the REPL, but because of how LISP is designed. It understands going into packages, importing stuff, inspecting values all naturally, not via some "interactive" mode / layer. You are speaking to the compiler directly and it understands your language. For this reason it is much more reliable and natural to embed a REPL in your development process in LISP, than in other languages.

lgrapenthin··on A Road to Common Lisp (2018)
The article is not trying to sell you on Lisp, in its first sentence it clarifies, that it is written for people who were "asking for advice on how to learn Common Lisp"...
lgrapenthin··on Jepsen: Datomic Pro 1.0.7075
You could include two transaction functions that constrain a transaction to different properties about the same fact and then alter that fact. I don't know of a practical usecase or that I ever encountered that, it would be extremely rare IME.
lgrapenthin··on Jepsen: Datomic Pro 1.0.7075
I wouldn't use it. The footgun is imaginary. I use Datomic for ten years and I can assure you that I never stepped on it. As a Datomic user you see transactions as clean small diffs, not as complicated multi step processes. This is actually much more pleasant to work with.
lgrapenthin··on Jepsen: Datomic Pro 1.0.7075
Somewhat unrelated ad docs: It appears that "Query" opens a deadlink
lgrapenthin··on Clojure: Managing throughput with virtual threads
Considering that 1.12 is close, its next in the pipeline I guess: https://ask.clojure.org/index.php/13366/virtual-thread-execu...
lgrapenthin··on Rama is a testament to the power of Clojure
There are no huge flaws with Datomic.
lgrapenthin··on HTML Attributes vs. DOM Properties
value is a property and an attribute. Your x is only an attribute.
lgrapenthin··on Spotify demonetizes all tracks under 1k streams
I recently demonitized Spotify and am very happy with Bandcamp and Newpipe.
lgrapenthin··on Clojure's machine learning ecosystem
You can just copy paste this and replace RELEASE with the version number. If you want to dig deeper, the CLI and deps options used here are well documented under https://clojure.org/reference/deps_and_cli
lgrapenthin··on Clojure's machine learning ecosystem
What? If anything, we have a "do-it-right" mentality :) The Clojure library ecosystem is very rich with new libraries coming out every week. We also reuse the rich Java library ecosystem to a large degree. I'm with Clojure for 10+ years and I don't "often end up writing custom code for a generic feature". Its quite the opposite. Clojure is a language that has hundreds of extremely well composing generic functions built in, that operate on a very rich set of first class immutable datastructures. Whatever Clojure you base your impressions on is very different from the one I know and use...
lgrapenthin··on Clojure's machine learning ecosystem
None of this is true.
lgrapenthin··on Clojure's machine learning ecosystem
Most Clojure devs I know already have lots of experience and can debug faster in their head, with the occasional help of printing a value. But check out this cool Clojure debugger, it even has time travel https://www.flow-storm.org/

We also have a debugger in Emacs/CIDER.

Your other complaints read like you haven't dug really far, or they are outdated.

lgrapenthin··on Clojure's machine learning ecosystem
Clojure focuses on quality over hype, at great success. Its hypesters never really understood Clojure, and have long moved on. So will the hypesters of Rust and other hyped languages, unless they get a chance to ruin them.
lgrapenthin··on WebSockets vs. Server-Sent-Events vs. Long-Polling vs. WebRTC vs. WebTransport
> Long-Polling: The least scalable due to the high server load generated by frequent connection establishment, making it suitable only as a fallback mechanism.

That makes no sense. Long-polling scales linearly like all the other ones as well.

lgrapenthin··on Emacs-copilot: Large language model code completion for Emacs
Have you seen modern React frontend dev in JS? They copy paste about 500-1000 LOC per day and also make occasional modifications. LLMs are very well suited for this kind of work.
lgrapenthin··on The 1988 shooting down of Flight 655 as a user interface disaster
I gave up when I realized that I have to click on each "tweet" to read more
lgrapenthin··on My mental model of Clojure transducers
Not even by far
lgrapenthin··on Morse, an open-source interactive tool for inspecting Clojure
I haven't seen leiningen based projects in a long time. Are you sure?
← PreviousPage 2 of 5Next →