EddieRingle

Discord isn't really the model to follow here, IMO. They killed their native Android app and moved to React Native, and now they're dropping React Native (while mobile somehow keeps "native UI", according to their CTO's tweet). If they wanted to maximize code reuse and accelerate feature development, they should have instead considered Kotlin Multiplatform, then they could've skipped the React Native detour while actually building apps that are native to the platform. (Rust and its cacophony of UI frameworks are not really platform-native anywhere, as far as I'm aware. Maybe Pop OS, but I don't know anyone targeting that specifically.)

This bit is obviously subjective, but Rust as a language is simply not ergonomic enough for a lot of the use cases people are trying to apply it to, especially UI development. Most of the Rust UI libraries I've seen to date either use a more imperative style, or attempt to replicate more declarative approaches like Compose UI or SwiftUI, but without the nice language aesthetics that make it simple to read and write. And if the counter-argument there is for LLMs to be reading and writing this stuff, that's a whole other can of worms: (1) The subsidized inference era is quickly coming to an end and (2) if you're using LLMs anyway, why not maintain apps that are as native to each platform as possible?

Likewise, a younger, more idealistic me thought it'd be great to use a GitHub-esque platform for laws. Pull Requests to suggest laws, gated behind reviews/approvals, branches so each house could work on their own versions before finally reconciling and merging into the Code, literally.

Actual site is https://krillion.io/ - the one you link embeds it in a frame.

I have no issues using it with llama.cpp.

I currently have a few VMs in a Proxmox cluster that serve as sandboxes, talking to various inference machines, all self-hosted (so I don't have to worry about having "enough credits" either).

Very neat. Almost reminds me of Android's databinding era (i.e. type-safe generated interfaces to XML Views). Though Android development quickly moved on to Compose UI, since Kotlin is expressive enough to cover all of the bases, I guess. And ever since then, I've personally grown annoyed with how much other ecosystems rely on templating. (In fact, I'm doubly annoyed that JetBrains picked YAML for Amper/Kotlin Toolchain. Since they had to add special templating to it anyway, why wouldn't they just use Kotlin or some subset?)

Like the other comments, I'm very confused at what this is meant to do other than promote a wanna-be Git competitor and yet another hyper-specific "conference". The post doesn't really make any arguments, even in the section that's suppose to make an argument. And for some reason they're adding GraphQL into the mix, somehow?

Dense models run at a very usable speed (Qwen 3.6 was running at ~50t/s last I looked) on my dual 7900 XTX desktop. (And before anyone brings it up, I did not buy them for this purpose, so the up-front cost is irrelevant in my case.)

> There’s no way to justify their valuations if they get downgraded to a pair programming tool.

Honestly I still don't see how they justify their valuations, period. If anything they're serious liabilities.

Open-weight models are improving and reaching "good enough" levels for more and more tasks. They're also known quantities; you know what you're getting with them and don't have to worry about the model silently (or not so silently) being switched out from under you (whether that's because Anthropic/OpenAI decides you're not worthy of their latest and greatest for one reason or another, or they switch you to a quantized model to save on compute, or they simply sunset the specific model you've been relying on).

And if the open-weight model doesn't run on your local hardware already, there are any number of hosting providers that will handle that for you (so you're back to just paying for colocation/cloud usage instead of nebulous tokens).

Closed models are improving as well, sure, but diminishing returns will eventually kick in (as they already have for various tasks, as I said).

So if not their models, where does their value come from? Just simple network effects/lock-in? "Normal" users will drift to other options if they start showing more and more ads, and enterprise customers will surely be looking for opportunities to avoid lock-in and reduce risk.

I think the last argument I've heard is that these valuations are basically a bet that Anthropic and/or OpenAI will achieve AGI that can fully replace human labor, so they'll essentially be able to sell that replacement labor to everyone. They haven't managed to pull that off, yet, however. Businesses that have tried to replace humans almost immediately realized either that the AI's capabilities were oversold or that they at least needed a human in the loop still, to some degree. And even if they do achieve AGI, that would surely become an issue of national security (they're already flirting with that today), so who's to say governments won't simply nationalize the best AI labs and either remove them from the economy entirely or perhaps even provide models as a public service to level the playing field?

That all sounds like a giant gamble, if anything. And it's incredibly frustrating to watch as someone that's been unemployed for a year because (a) budgets are being burned on tokens and (b) LLM-generated applications are flooding hiring teams and preventing real people from being seen. (Not to mention, as someone that spends a lot of time in gaming circles, the fact that DRAM and flash storage is quickly becoming inaccessible is just an additional frustration that means people can't even find temporary relief in entertainment.) I can only hope this bubble finally implodes before I lose my house.

Also SQLDelight for Kotlin: https://sqldelight.github.io/sqldelight/

Compose UI apps can be compiled to native binaries already, via Kotlin's LLVM backend, though at the moment only the macOS/iOS targets have proper (official) support. Last I looked (a few years ago now), the Linux and Windows targets shouldn't be too far off, since it's all built on top of Skia already, someone just needs to care enough to put in the work. (But since right now you already get coverage for all platforms between JVM and Wasm, not to mention hot reload support on the JVM, there's little motivation to do so.)

Both can be true, no? The administration has a vendetta (justified or not), and Anthropic's behavior gave them a reason to act on it.

Let's expand the actual quote we're responding to:

> the borrow checker woes can be offloaded to the model, you focus on all the other programming logic

Then the person you responded to asked if "you" really do "focus on all the other programming logic", given that "the model" deals with the borrow checker. In other words, they're asking about the work the actual human is doing at that point. You then replied talking about the model again and token budgets. In effect, you brushed the question under the rug and imply that _everything_ is offloaded to the model, no focus by the human required.

They're not talking about the model, and they're not talking about token budgets.

> Speaks volumes to the strengths of the language, also speaks volumes that LLMs lift the barrier of entry for Rust programming, the borrow checker woes can be offloaded to the model, you focus on all the other programming logic.

I get the opposite impression. If they aren't confident enough to write it by hand, I think it means the language is either hard to write, hard to read, or both. And by delegating to a LLM, there's no "barrier of entry" being lifted, it's just saving you typing time (like it would if it was being translated to C or Kotlin). If they actually decide to "focus on all the other programming logic" and they aren't just vibe coding this, they'll still need to be able to understand and reason about the code.

I wouldn't say Compose UI/Flutter/SwiftUI are "implementing React", but if your point is that other platforms have better solutions than JSX (plus all the bloat React adds to applications), I absolutely agree.

I'm always taken aback a little when I read through HN and see how little mind share Kotlin and its ecosystem has here. JetBrains has done a pretty good job of creating something that can fill many different niches (especially considering they're not one of the giant tech companies with virtually unlimited budgets), but it seems people don't even realize it exists, for whatever reason. It doesn't even need to run on a JVM in many cases, if that's some sort of barrier.

> I think ECS is a new enough architecture that the patterns are still very much folk lore.

ECS is a pretty old idea, built on concepts that are even older. I was playing around with an ECS-like engine of my own in C over 10 years ago, based on blog posts and talks that are now 20-25 years old. Even the Wikipedia article for ECS can trace the origins back to the 1960s. (Though obviously it hasn't been applied to video games for quite that long.)

Nowadays I'd probably reach for Godot and Kotlin if I just wanted to build a game in an ergonomic language on a solid foundation. You could still apply ECS concepts there, as well.

According to that article, the data they analyzed was API prices from LLM providers, not their actual cost to perform the inference. From that perspective, it's entirely possible to make "the cost of inference" appear to decline by simply subsidizing it more. The authors even hint at the same possibility in the overview:

> Note that while the data insight provides some commentary on what factors drive these price drops, we did not explicitly model these factors. Reduced profit margins may explain some of the drops in price, but we didn’t find clear evidence for this.

Sent an email out just a bit ago! Please let me know if it doesn't arrive for whatever reason.

EDIT: Looks like my comment was detached from its thread (https://news.ycombinator.com/item?id=46857847) without a comment explaining why. It's not breaking any of the stated rules at the top, and it seems like it would be common sense to let someone know they should expect a message (especially considering how temperamental email filtering can be these days). If this _is_ against the rules, I'd appreciate it if future hiring threads stated as such so that people like myself that have been trying to find a job for 7+ months can stop wasting our time here. I understand how it can be challenging to moderate a forum like HN, but the moderation priorities seem pretty disappointing, unfortunately.

> I applied and got rejected without feedback. They stated that there was a high volume of strong applicants (if there were, why are they posting again?)

This is the case for the vast majority of companies posting jobs here and elsewhere (e.g., LinkedIn) right now. I've been looking for the past 7 months after a lay-off and that exact reply is the most common response I've seen (because it's an automated response). Well, most common after not hearing back at all, of course.

> Plus, it seems some of y’all love to hate the very industry which puts a roof over your head. You’re hoping and praying that it all burns down—yet where will that leave you? How do you feel about becoming a plumber—-until the robots take that job?

This probably isn't a line of argument you want to go down. I've been unemployed for 7 months, in part due to how difficult it is to get so much as an intro call because so many people have totally automated the process of spamming every open job posting with as many resumes (many of which were likely LLM-generated as well) as possible.

Kotlin has a LLVM backend, among others.

I didn't get as far as experiencing their billing system; I decided to finally look into Claude recently and discovered that their pricing page's content area was completely blank. It loads on my phone if I'm off WiFi, so I assume my PiHole is blocking something there. That being said, if anyone at Anthropic is reading this, I'm primarily an Android dev but if you'd like to hire me to write a simple static HTML page just like I taught myself back when I was in elementary school, I think it could significantly improve your conversion rates or whatever, and I've been unable to even get an interview anywhere for the past 7 months so I really think we'd be helping each other out.

(Suffice to say I passed on Claude/Claude Code for the time being.)

They're citing another section of the article rather than the cherry picked quotes they were responding to.

None of those will get you a "native" app, but they might get you most of the way to a cross-platform app.

Are you familiar with Kotlin's DataFrame? (https://github.com/Kotlin/dataframe)

JetBrains also keeps a list of other data analysis libraries for Kotlin (and Java) as well: https://kotlinlang.org/docs/data-analysis-libraries.html

On Android it more or less just uses the accessibility APIs to grab the actual text, you can do it without using Google Assistant even by selecting text inside an app's thumbnail window from the Recent Apps screen.

> I am uninterested in `you can do that in git with [insert esoteric commands]`.

Why? If the only requirements you specified are that you're looking for something that is compatible with Git but with better ergonomics, wouldn't something that wraps Git (whether that's via aliases or something more comprehensive) fit the bill?

I'm actually surprised to learn that Notion mandates on-site. It gives the impression that the leadership doesn't believe in their own product (which revolves entirely around collaborating on work online).