MurphyA/hacker-news huggingface dataset:
by nebula8804 | 2025-06-15 09:56:08+00:00
Why would they even entertain the idea of even talking to a Chinese OEM. This is obviously very important technology and Google must know the Chinese history of IP theft. They are not in the Chinese market because of this!

Zeeker must have given them such an unbelievable deal that Google couldn't pass it up. Either that or the other OEMs have really soured on them. I always thought the idea of OEMs being reduced to generic white label badges while companies like Waymo make all the profit on the future of "on demand" transportation is not appealing to them. Companies like GM tried to cut Waymo out by buying Cruise but it hasn't worked out. I guess if the stock price of one of these OEMs falls enough, maybe Waymo can just buy them out but do they really want to take on that obligation?
by sali0 | 2025-06-15 10:00:07+00:00
noob question, i'm currently adding telemetry to my backend.

I was at first implementing otel throughout my api, but ran into some minor headaches and a lot of boilerplate. I shopped a bit around and saw that Sentry has a lot of nice integrations everywhere, and seems to have all the same features (metrics, traces, error reporting). I'm considering just using Sentry for both backend and frontend and other pieces as well.

Curious if anyone has thoughts on this. Assuming Sentry can fulfill our requirements, the only thing taht really concerns me is vendor-lockin. But I'm wondering other people's thoughts
by hyperman1 | 2025-06-15 10:01:31+00:00
Oh man. I've seen an org where the stored procedures were written by a different team, and friction was high.

Then one java dev found a glaring sql injection hole. The whole app quickly reorganized around using it as an API for everything. Management was pleased speed went up and bugs went down, DBAs were pleased for less work, and Java devs were pleased they could understand what was going on in the app. Everybody happy I guess?
Show HN: Building Hugo – An AI coding agent
by bosborne | 2025-06-15 10:04:24+00:00
Most AI coding tools just follow instructions. Hugo is different.

Instead of blindly generating code, Hugo:

- Asks clarifying questions when requirements are unclear - Considers the bigger picture of your project - Remembers your entire project context between sessions (no more re-explaining everything!) - Uses layered memory: short-term for individual tasks, compressed long-term for project continuity - Plans, observes, and reflects on solutions before coding

It's designed to be the curious, thoughtful engineer you want on your team - one that actually remembers what you worked on yesterday.

Early access waitlist is live: https://hugo-agent.surge.sh/

Built by a solo dev passionate about making AI that truly collaborates rather than just executes. Would love your feedback!
by jorvi | 2025-06-15 10:07:02+00:00
Yeah, you're right. I had to do some Google-fu, but the timeline is:

MacBook 2008[0] into MacBook Air 2010[1].

The MacBook 2008 was the chunky unibody that would be inherited by the Pro line. This model had non-backlit keys on the cheaper model, backlit on the more expensive. Only 13", 1280x800.

The Air 2010 had no backlit keys, and 11" or 13", 1366x768. Despite having the better processor it overheated quickly. The battery life was pretty abysmal too.

There is also the MacBook Retina 2015 12" [2]. But this had all the modern amenities.

The MacBook Retina would go on to be killed, but like you said, some of the design decisions would end up being inherited by the Air line.

I guess I got my wires crossed in regards to the Air and the MacBook Retina 12".

[0]https://support.apple.com/en-lk/112512

[1]https://support.apple.com/en-lb/112580

[2] https://support.apple.com/en-us/112442
Ask HN: How to increase LLM inference speed?
by InkCanon | 2025-06-15 10:08:28+00:00
Hi HN,

I'm building software that has a very tight feedback loop with the user. One part involves a short (few hundred tokens) response from an LLM. By far this is the biggest UX problem - currently DeepSeek's total time taken can reach 10 seconds, which is horrific. Would it be possible to practically reduce the speed to maybe ~2 seconds? The LLM just asks to rephrase (while preserving meaning) of a short text, so it does not need to be SOTA. On the whole faster inference time is much more important.
by janjones | 2025-06-15 10:09:46+00:00
> You can't do much of anything in .NET without referencing Nuget assemblies.

And referencing NuGet assemblies is of course supported via the #:package directive. It's just that referencing DLLs directly is not a common scenario, hence it's not supported for now (but can be added later).

> Agreeing with others, '#r "nuget:' should at least be an option.

Thanks, we hear you and plan to add support for it, see https://github.com/dotnet/sdk/issues/49199

> And otherwise (but I guess regarless if you stick with this syntax) you will have to add another tab to Nuget called "dotnet run". "Script & Interactive" is already present in Nuget and shows the #r syntax for a reference.

Agree but also note that the ".NET CLI" tab which tells you to run "dotnet add package" should also work in near future, see https://github.com/dotnet/sdk/issues/49200.
by latexr | 2025-06-15 10:09:56+00:00
> (…) sounds more impressive (…) sounds more impressive (…)

You keep saying that, but my question was why they considered it to be more impressive. I understand an article might want anything to sound more impressive for clicks.

> If this is the case, isn't it quite clear

And no, I don’t agree that taking so long immediately makes it more impressive that a student did it. How many experts are actively searching? And how many students? There are always more of the latter than the former. After long, fortuitous encounters (which anyone can have) become more common.
by jpgvm | 2025-06-15 10:10:26+00:00
It really depends on the origin of the system to be replaced. If it was never designed to be replaceable you are usually in for a bad time. Similarly if the drive to replace it comes from new folk that simply don't understand the original system you are probably completely doomed.

I often write code with full intention of replacing it, generally by writing it in such a way it's replacement is forced. That latter bit is pretty important because systems generate inertia, you need to have some hard forcing function baked into prevent it ossifying.

i.e my current project is to replace a pretty awful pile of Bash I wrote last year and replace it with a much more sophisticated and automated system in Golang. The new system is already in production and the old tools are being phased out.

Writing the original in Bash was how I basically ensured it would get rewritten and not continually upgraded/morphed into something grotesque. There was a ton of pushback, lots of people saying "why not Go! why not Python! This is an awful decision, 3k LOC of Bash is an unmaintainable nightmare!". Literally all of those people missed the point.

Building simple systems that you 100% will replace (not intend, that really isn't the same thing) is a really good pattern to find a real understanding of the solution space before building something gold plated/spaceship-like.

It generally means once you implement the follow up it very rarely becomes "legacy" software without horrible mismanagement, i.e bringing in new management that wants to rewrite things for the sake of rewriting them, usually in some FoTM nonsense.
by erwan577 | 2025-06-15 10:14:18+00:00
I also lack an internal monologue and have strong aphantasia, so the idea that I might not be conscious made me a bit uneasy—it just felt wrong, somehow. For now, the best I can say is that my worldview, which includes self-consciousness, is abstract. I can put it into words, but most of the time, it doesn’t feel necessary.
by bgnn | 2025-06-15 10:14:36+00:00
People think this is not relevant to real world problems but it actually is, albeit all the calculations aren't that relevant. Silicon substrate's resistance is basically an infinitely large grid of unut resistances at the distances relevant for a local point of an IC. Note that silicon substrate is often heavily doped (p-type) and all info you get from the fab is it's resistivity (often somewhere between 1 to 100 ohm per cm). For the most advanced tech nodes its often 10 ohm/cm. If you need to develop some intuition about noise coupling via the substrate you have to think that it's a grid instead of just calculating the resustance between point A and B. We need to distribute a grid of substrate contacts to collect the noisy currents too. So the grid shows up again!
by bsa_d1 | 2025-06-15 10:19:15+00:00
A lightweight CLI (llama‑optimus) that uses Optuna-library to auto-tune performance flags for llama.cpp: batch sizes, thread counts, GPU layers, flash attention. It finds optimal config in minutes and outputs commands ready for llama-server or llama-bench. It supports Apple Silicon, Linux, NVIDIA.

Install from PyPi with: `pip install llama-optimus` and it runs in shell with this line: llama-optimus --llama-bin ~/llama.cpp/build/bin --model ./models/my-model.gguf --metric tg --trials 30 --repeat 2

It helps to find the llama.cpp flags to optimize token generation speed (tg), prompt processing (pp), or the average (mean); option for target --metric <tg|pp|mean>

Do you know any other/similar tool?
by chii | 2025-06-15 10:19:29+00:00
it's why you take them to small claims court. Unfortunately, the terms and conditions have made sure they are clear of small claims by forcing you to do arbitration, which is more expensive for you than them (in relative terms, unless they also put into the T&C to pay for your arbitration costs - which some companies have done iirc, such as epic games).

Chargebacks are the last resort - only really worth doing if it is a large amount that you will miss if not charged back.
by FunnyLookinHat | 2025-06-15 10:20:03+00:00
I think you're looking at OTel from a strictly infrastructure perspective - which Cloudwatch does effectively solve without any added effort. But OTel really begins to shine when you instrument your backends. Some languages (Node.js) have a whole slew of auto-instrumentation, giving you rich traces with spans detailing each step of the http request, every SQL query, and even usage of AWS services. Making those traces even more valuable is that they're linked across services.

We've frequently seen a slowdown or error at the top of our stack, and the teams are able to immediately pinpoint the problem as a downstream service. Not only that, they can see the specific issue in the downstream service almost immediately!

Once you get to that level of detail, having your infrastructure metrics pulled into your Otel provider does start to make some sense. If you observe a slowdown in a service, being able to see that the DB CPU is pegged at the same time is meaningful, etc.

[Edit - Typo!]
by TheDong | 2025-06-15 10:20:09+00:00
idk, google has a nice list of things that seem like they'll never be profitable, but it keeps running em. Like, google patents, google books, google translate... none of those make money, right? Chromium only makes money indirectly I think, and they invest a ton of engineering resources in that.

Google kills stuff, but they don't kill everything, just stuff that no one is working on (like google reader, I think all the people who cared about the code just quit), or stuff that is specifically counter to some exec's strategy (like killing a bunch of chat software to centralize on Google+ or whatever it is now)
by supriyo-biswas | 2025-06-15 10:20:34+00:00
I understand that the showcased project is meant as a "joke", but a few days ago I briefly saw a Recaptcha with a hand icon amongst its three other options. Curious, I clicked on the hand and it asked me for consent to record my gesture, with an assurance that the video would not be stored.

I've never been able to see the hand icon ever since and no one else seems to have documented its appearance. However, after some searching, I was able to find [1] (archived at [2]) which should serve as sufficient proof of this existing and not something that my mind hallucinated out of those "drink a verification can" memes.

(For people trying to visit [1], you should copy the square brackets at the end of the link, which HN leaves out when adding the anchor tag.)

[1] https://google.com/recaptcha/challenge/hand-gestures?d=[]

[2] https://archive.is/nYJjh
by matiasmolinas | 2025-06-15 10:23:30+00:00
For the past few months, my collaborator Ismael Faro and I have been building a Python framework for creating self-evolving AI agent systems. It was powerful, with a smart library, an agent bus, and tools for evolution. But it had a problem: it was becoming incredibly complex. Even using AI coding agents to help improve the framework felt slow and cumbersome. While using Claude Code to work on this, I had a realization. The LLM was so good at understanding and manipulating the project structure that the Python code itself was starting to feel like unnecessary boilerplate. So, as an experiment, I tried to see what the absolute minimum viable agent framework would look like. What if I threw out all the Python and just kept the core concepts, but defined them in simple markdown? It worked. Surprisingly well. I'm sharing the result today. This is the framework-core. It's an entire agentic framework in just 3 markdown files: https://github.com/EvolvingAgentsLabs/framework-core SystemAgent.md: The "kernel" prompt that tells the LLM how to plan, execute, and learn. SmartLibrary.md: A markdown list that acts as a "package manager" for other markdown-defined tools. SmartMemory.md: An append-only log where the agent records its experiences to improve over time. The "runtime" is just a powerful LLM (like Claude in a VSCode project). You give it a high-level goal, and it uses these three files to orchestrate a solution. I then tried to use this for non-coding, white-collar tasks—legal analysis, marketing campaign generation—and it worked there too. The agent was able to identify missing capabilities (like a "RiskAnalysisTool") and write the markdown for the new tool itself before using it. This led me down a rabbit hole, and I ended up building a full-fledged OS simulation on top of this core concept, which we're calling LLMUNIX. It has a virtual file system, a process manager, and a command interpreter, all defined in markdown. You can see that more advanced project here: https://github.com/EvolvingAgentsLabs/llmunix This is all "alpha" and a space for experimentation under our new Evolving Agents Labs organization. I'm sharing this because the simplicity of the approach surprised me. It feels like it democratizes the ability to create complex agentic systems. If you can write a to-do list, you can design an AI agent. I'd love to get the HN community's feedback. Is this a novelty, or is there a real future in treating markdown as a programming language for LLMs? What are the limits I'm not seeing yet? Thanks for checking it out.
by simonh | 2025-06-15 10:23:44+00:00
A claim is not an assertion. I don’t see any assertion the hard problem doesn’t exist here, just expression of a belief it may be solvable and an outline of maybe how.

> Simply declaring it as functional is begging the question.

Nobody is ‘declaring’ any such thing. I loathe this kind of lazy pejorative attack accusing someone of asserting, declaring something, just for having the temerity to offer a proposed explanation you happen to disagree with.

What your last paragraph is saying is that stage 1 isn’t conscious therefore stage 5 isn’t. To argue against stage 5 you need to actually address stage 5, against which there are plenty of legitimate lines of criticism.
by xienze | 2025-06-15 10:24:20+00:00
But the Tower of Hanoi can be solved without "tools" by humans, simply by understanding the problem, thinking about the solution, and writing it out. Having the LLM shell out to a Python example that it "wrote" (or rather, "pasted" since surely a Python solution to the Tower of Hanoi was part of its training set) is akin to a human Googling "program to solve Tower of Hanoi", copy-pasting and running the solution. Yes the LLM has "reasoned" that the solution to the problem is call out to a solution that it "knows" is out there, but that's not really "thinking" about how to solve a problem in the human sense.

What happens when some novel Tower of Hanoi-esque puzzle is presented and there's nothing available in its training set to reference as an executable solution? A human can reason about and present a solution, but an LLM? Ehh...
by srikanthccv | 2025-06-15 10:24:37+00:00
>I was at first implementing otel throughout my api, but ran into some minor headaches and a lot of boilerplate

OTeL also has numerous integrations https://opentelemetry.io/ecosystem/registry/. In contrast, Sentry lacks traditional metrics and other capabilities that OTeL offers. IIRC, Sentry experimented with "DDM" (Delightful Developer Metrics), but this feature was deprecated and removed while still in alpha/beta.

Sentry excels at error tracking and provides excellent browser integration. This might be sufficient for your needs, but if you're looking for the comprehensive observability features that OpenTelemetry provides, you'd likely need a full observability platform.
by pengstrom | 2025-06-15 10:24:53+00:00
My stab:

2: implicit world. Reacts to but not modeled. 3: explicit world and your separation from it. 4: Model that includes other intelligences of level 3 that you have to take into consideration. World resources can be shared or competes for. 5: Language. Model of others as yourself, their model include yours too. Mutual recursion. Information can be transmitted mind-to mind.
by srean | 2025-06-15 10:27:24+00:00
In my very early twenties I used to seek out a secluded and a then inactive graveyard to do some rumination, or just to unwind. It bordered a marshy water body and the sun going down against it looked good.

All the graves were in states of severe disrepair and worse (vandalism and theft). Except one. There was this grave of a girl child. Going by the date engraved, she would be same age as me, but she had died six years old, or about that age -- my memories are hazy now.

For some reason no one had touched that grave. No vandalism. No theft. Once in a while even flowers.

Once in a while humanity does redeem itself.
by bowsamic | 2025-06-15 10:28:07+00:00
Having developed in a wide variety of different languages in my free time, I really think the idea that languages like lisp and smalltalk give a sense of creative freedom is pretty overblown.

I have realised recently that there are much more concrete barriers to creative expression in coding: many of us are carrying around iPhones that you cannot write applications for, even for yourself, without paying a $100 a year fee. All the ways the language makes you feel means little compared to whether or not you can actually write code for your computer. The person who makes the computer can decide if you are allowed to be creative with it. And, as a society, we have decided (or perhaps been implicitly brainwashed?) to not want to be creative with our computers. In such a situation, the distinction between Java's OOP and Lisp's "computational ideas and expression" means very little.

A bit of a "Stallman was right" moment for me.
by slooonz | 2025-06-15 10:30:58+00:00
Operational concerns trumps raw performances most of the time. Stored procedures live in a different CI/CD environment, with a different testing framework (if there’s even one), on a different deployment lifecycle, using a different language than my main code. It is also essentially an un-pinnable dependency. Too much pain for the gain.

Now, give me ephemeral, per-connection procedures (call them unstored procedures for fun) that I can write in the language I want but that run on provider side, sure I’ll happily use them.
by Dzugaru | 2025-06-15 10:31:33+00:00
> just as humans shouldn’t serve as calculators

But they definitely could and were [0]. You just employ multiple, and cross check - with the ability of every single one to also double check and correct errors.

LLMs cannot double check, and multiples won't really help (I suspect ultimately for the same reason - exponential multiplication of errors [1])

[0] https://en.wikipedia.org/wiki/Computer_(occupation)

[1] https://www.tobyord.com/writing/half-life
by selfdb_io | 2025-06-15 10:31:43+00:00
Try out our live demo to judge for yourself:

link: dashboard.selfdb.io --> anon-key found in the settings pages. user: admin@example.com password: adminpassword

also git clone and run our sample apps: swift: https://github.com/Selfdb-io/selfdb-swift-app expo: https://github.com/Selfdb-io/selfdb-expo-app react vite: https://github.com/Selfdb-io/selfdb-react-vite
by timonv | 2025-06-15 10:32:48+00:00
Hey everyone,

Just shipped a major release for Swiftide. Swiftide provides the building blocks to build composable agentic and RAG applications.

Shoutout to wulawulu for contributing a Kafka integration! <3

A major new staple is a straight-forward way for human-in-the-loop interaction. Human-in-the-loop pattern is a common solution for GenAI agents to provide them with feedback and some measure of safety.

Additionally there's a host of new features, improvements, and fixes. You can find the project on [github](https://github.com/bosun-ai/swiftide).
by ndsipa_pomu | 2025-06-15 10:33:47+00:00
The example used of attacking rush hour highways made me think of just how effective that could be. However, maybe drones aren't the best means of attack - I'd think that an ordinary vehicle could simply have a passenger equipped with a suitable laser pointer and simply shine it into the eyes of a following driver. That would leave very little evidence and of course laser pointers can easily be concealed.
by masklinn | 2025-06-15 10:34:07+00:00
> AFAIK one factor that accounts for the amazing longevity of old paintings was the compatibility between their many layers. The canvas, the primer, the paint and the medium were all derived from the same plant: flax.

AFAIK that's largely untrue in the general case:

- Canvas painting only appeared in the 15th century, and took a while to spread, paintings before the 17th century (16th in some locations) tend to be on wood panels e.g. raphael and da vinci painted almost exclusively on board.

- Canvas is almost always coated with gesso which at the time would use rabbitskin glue as binder, no flax there.

- While flaxseed was the most common drying oil (in europe), walnut, poppyseed, and safflower, were also in use. And additives were usually mixed in to manage the viscosity of the paint, so even in the "best" case it's not like the paint would be just pigments in linseed oil unless it's a very early oil painting, which wouldn't have been on canvas.

- As for varnishes, not only was flax not the only drying oil for oil varnishes, varnishes could also be "spirit" varnishes (with a resin dissolved into a solvent like alcohol or turpentine), waxes were also sometimes used as or in varnishes.
by virtualritz | 2025-06-15 10:34:16+00:00
Curiously, when I play this back on my Android phone, after entering full screen, I can not exit/close the tab go to another tab. I can also not reach the system launcher any more.

I had to kill Chrome via system prefs to make it stop.

Seems like this video not only exposes the issues with HDR but also a rather weird bug on Chrome/Android.
by chatmasta | 2025-06-15 10:34:29+00:00
It’s also a smaller area. I can tap the opposite corners of the board on my phone faster than I could click them on my computer.

Some chess snobs react with derision to using a mobile app to play… but I think they must be using the Chess.com app, which is awful - low response times, input lag, etc - and not the Lichess app which is snappy and reliable.