MurphyA/hacker-news huggingface dataset:
by topspin | 2025-08-20 01:02:59+00:00
> it should be possible to completely forego the pulsebased approach and only drive the motors using regular (and less frequent in comparison to pulses) position instructions

Since that capability is present, it's probably worth your while to apply it. Good motion control is hard, but important. Unnecessary vibration due to phase noise in the pulse train is an example of the subtleties that matter at high frequency. Excessive force generated when moving large masses can prematurely wear drive components and, over time, backlash increases and you get precision and repeatability problems. Well managed motion control will mitigate these things.
by CharlesW | 2025-08-20 01:03:04+00:00
This should've been an .agents¹ with an index.md.

For tiny, throwaway projects, a monolithic .md file is fine. A folder allows more complex projects to use "just enough hierarchy" to provide structure, with index.md as the entry point. Along with top-level universal guidance, it can include an organization guide (easily maintained with the help of LLMs).

index.md ├── auth.md ├── performance.md ├── code_quality ├── data_layer ├── testing └── etc

In my experience, this works loads better than the "one giant file" method. It lets LLMs/agents add relevant context without wasting tokens on unrelated context, reduces noise/improves response accuracy, and is easier to maintain for both humans and LLMs alike.

¹ Ideally with a better name than ".agents", like ".codebots" or ".context".
by nomel | 2025-08-20 01:03:46+00:00
> The solution is to have Level 2 and Level 3 charging _everywhere_.

I somewhat agree with this. My response was specifically, which I quoted, about "slow chargers" at office or transit, which I assumed was level 1. Level 2 is 8x faster, and can accommodate a 25 mile commute in two hours, rather than a net loss of change over 8 hours.

Level 1, at these locations, doesn't make sense.
by Terr_ | 2025-08-20 01:04:13+00:00
On reflection I was incorrect to mention Napster, which (at least in its most-popular incarnation) was still centralized for indexing and searching, with P2P only for bulk file data. Please pretend said "Gnutella" alone.

> The analogy is [the P2P application] on a LAN.

The analogy is the P2P application where regular clients can only discover a Special Master Client that must be running on a fixed IP, which only permits connections if you have credentials for a user-account arranged in advance.

In each case, the system's centerpiece feature is being voided, but that feature is different between them.

1. For "Blockchain", the centerpiece is unrestricted participation. (Other decentralization is an indirect effect.)

2. For P2P file sharing, the centerpiece is how nobody needs to run an expensive/vulnerable central server, but it wasn't a contradiction in terms to have a private peer-network.
Ask HN: MCP/API search vs. vector search – what's winning for you?
by ngkw | 2025-08-20 01:04:40+00:00
TL;DR: I have a hunch that demand for classic RAG (embeddings + vector DB) will shrink. Reasons:

1. Embedding ops cost (re-indexing, freshness) is high.

2. LLMs are getting good at iterative query expansion over plain search APIs (BM25-style).

3. Embedding quality is still uneven across domains/languages. Curious what you are actually seeing in production.

Context: We’re a \~10-person team inside a large company. People use different UIs (ChatGPT, Claude, Dify, etc.). Cost/security aren’t our main issues; we just want higher throughput. We can wire MCP-style connectors (Notion/Slack/Drive) or run our own vector index—trying to pick battles that really move the needle.

Hypotheses I’m testing:

* For fast-changing corp knowledge, BM25 + LLM query expansion + light re-ranking beats maintaining a vector store (lower ops, decent recall).

* MCP/API search gives “good enough” docs if you union a few expanded queries and re-rank.

* Vectors still win for long-tail semantic matches and noisy phrasing—but only when content is relatively stable or you can afford frequent re-embeds.

What I want from HN (war stories, not vendor pitches):

1. Have you sunset or avoided vector DBs because ops/freshness pain outweighed gains? What were the data size, update rate, and latency targets?

2. If you kept vectors, what made them clearly superior (metrics, error classes, language/domain)? Any concrete thresholds (docs/day churn, avg doc length, query mix) where vectors start paying off?

3. Anyone running pure API search + LLM query expansion (multi-query, aggregation, re-rank) at scale? How many queries per task? Latency/cost vs. vector search?

4. Hybrid setups that worked: e.g., API search to narrow → vector re-rank; or vector recall → LLM judge → final set. What cut false positives/negatives the most?

5. Multilingual/Japanese/domain jargon: where do embeddings still fail you? Did re-ranking (LLM or classic) fix it?

6. Freshness strategies without vectors: caching, recency boosts, metadata filters? What actually reduced “stale answer” complaints?

7. For MCP-style connectors (Notion/Slack/Drive): do you rely on vendor search, or do you replicate content and index yourself? Why?

8. If you’d start from scratch today for a 10-person team, what baseline would you ship first?

Why I’m asking: Our goal is throughput (less time hunting, more time shipping). I’m leaning to:

* Phase 1: MCP/API search + LLM query expansion (3–5 queries), union top-N, local re-rank; no vectors. * Phase 2 (only if needed): add a vector index for the failure cases we can’t fix with expansion/re-rank.

Happy to share a summary of takeaways after the thread. Thanks!
by potato3732842 | 2025-08-20 01:05:35+00:00
Yeah the non-plate based stuff is way, way, way higher quality and way worse than people give it credit for. 10yr ago I was working on similar software in military contexts from the late 00s and it was scary then.

My two takes on the single minded focus on plate number records are as follow.

The cynic in me says it "is" about the LPR because the, roughly speaking, white collar middle class white people who suddenly now seem to care mostly drive new enough stuff to not be piled on with bumper stickers, have color mismatch, dings, etc, etc. and they care only so far as it effects them and they don't want to completely not track the poors and their sketchy vehicles.

The non-cynic in me says that breaking the information chain is good enough. Knowing a silver Camry has been coming and going and where doesn't really mean anything. It's being able to automatically tie that, via a plate number and corresponding records, back to a person. If someone at a later time decides the care can go looking, but it renders much harder a lot of bullshit "find me everyone who's too rich to be driving through Kensington because they're probably there for drugs" fishing from behind a keyboard expeditions, which is a huge plus.
by segfault99 | 2025-08-20 01:06:33+00:00
Bingo. We certainly learned about Cooley-Tukey in undergrad back then. That power station was 100% Hitachi Heavy Industries turnkey. The control rooms had Hitachi mainframe and some minicomputers running proprietary real time OS (I guess). These were the days when the video controller for a colour industrial process control raster display CRT was a waist-high cabinet. So you'd transduce the flicker and then transmit it via analogue current loop to a rack in the control room annex, convert back to voltage, A/D it... and crunch the FFT on one of the control room computers. Something like that. Cheap distributed compute just wasn't a thing at the time.
by mike_d | 2025-08-20 01:07:38+00:00
> protecting against an authoritative name server operator from maliciously modifying the zone data in their server was not a significant consideration in any of the IETF/implementation discussions I was in

Honestly this statement is not at all surprising. I would love to hear your perspective on what problem they thought was being solved.

Ensuring you have received a correct copy of a zone is the one thing we did get out of DNSSEC.

> I ran ISC during the development of BIND 9.0 and participated quite heavily in DNS-related working groups

Then we must have crossed paths. I'll happily buy you a beer or three next time.

> you have to take the steps DNSSEC takes

Ehhh. We are 30 years on and the current state is: recursive resolvers can strip DNSSEC and nothing happens but if they turn on validation things occasionally break.

Transport security has solved most of the real world problems and is being rapidly adopted: https://stats.labs.apnic.net/edns
by godelski | 2025-08-20 01:09:47+00:00
All to achieve something that could be done with a Raspberry Pi. You could do all this locally too.

https://gist.github.com/mgarratt/afb3b57a08e2eb2479eb6083a86...

https://www.xda-developers.com/ollama-ai-comparison-raspberr...

https://www.xda-developers.com/raspberry-pi-voice-assistant-...

https://www.youtube.com/watch?v=o1sN1lB76EA
by porridgeraisin | 2025-08-20 01:10:39+00:00
The study, conducted by University of California, Santa Barbara’s Dan C. Baciu, and published on the Preprints.org server, compares the Hymn to Nikkal with the Rig Veda, one of the oldest Indian sacred texts. Using computer-assisted rhythm and melody mapping, Baciu’s study demonstrated astonishing parallels between the two pieces. Baciu explained that one in five Rig Veda verses ends with the same cadence as the Hymn to Nikkal. The odds of this occurring by accident are less than one in a million.
Show HN: IndieRadar – AI finds build-worthy problems on Reddit
by howardV | 2025-08-20 01:11:00+00:00
Hey HN! I’m building IndieRadar, an AI-powered scout that trawls technical subreddits and turns raw posts into actionable “opportunity cards.” Each card includes: • Demand score (0-10) – based on intent phrases, failed attempts, and impact • Type (billing | workflow | missing-feature…) • Urgency & pay-signal (0-3) • A compliant follow-up draft so you don’t break subreddit rules

Why? • I wasted hours combing r/IndieHackers & r/webdev, only to realise 90 % is noise. • Generic “trending keywords” tools ignore real purchase intent. • Cold-DM is spammy; I want data-backed pull signals instead of push outreach.

How it works 1. Pick subreddits / topics 2. Keyword & rule-based filter 3. LLM labels high-potential posts (we only run AI on likely hits to keep costs low) 4. Alerts in real-time or a 3-minute daily digest (Email/Slack/Webhook)

Ask • Would this save you research time? • Would you use？ • Do you have any good suggestions? • Which community should we support next (HN, PH, GitHub Issues are on the roadmap)?

Try the private beta: drop your email at indieradar.dev (7-day trial, no CC).

Promise: no auto-posting, no data-selling.

Thanks! Happy to answer anything about scoring heuristics, Reddit API woes, or launching without spamming.
by eviks | 2025-08-20 01:11:08+00:00
You're not doing exactly the same tasks in other apps like you do in a browser, so you don't have browser-specific workflows you're used to that would break down.

For example, you have a browser where you can set up a shortcut _C_ to copy the current page URL to your clipboard. You've developed muscle memory of doing that, so feel it in another browser where it can't be set up that way.

You don't need that in a database client, so you'll never notice the difference there because you'll never use that shortcut
by ryukoposting | 2025-08-20 01:11:44+00:00
Looks like an absolute riot (heh).

Glancing at the sample code, the API looks quite pretty. It fits nicely with the "imperative-ish C++" idioms throughout most of the Arduino SDK. The reliance on try/catch statements is peculiar. If I'm doing something that demands a multitasking kernel, Arduino is never the first thing I'm going to reach for. Looks pretty nicely done, though.
by prmph | 2025-08-20 01:12:25+00:00
The agents instructions file needs to be hierarchical; It's a pain managing multiple agents.md files with a lot of duplication between them for different projects, even in a mono-repo. we probably need a tool for this.

In any case, I increasingly question the use of an agents file. What's the point, then the agent forget about them every few prompt, and need to be constantly reminded to go through the file again and again?

Another thought: are folks committing their AGENTS.md? If so, do you feel comfortable with the world knowing that a project was built with the help of AI? If not, how do you durably persist the file?
by nomel | 2025-08-20 01:13:00+00:00
> I don’t think it’s the battery specs holding back most buyers.

First link shows it's, at least, the primary (majority) concern for purchase. Price is part of the battery tech/chemistry package (~40% BEV price is battery), which seems to be the real killer:

> Only 33 percent of global survey respondents say they are likely or very likely to buy an EV at current price levels
by blinkymach12 | 2025-08-20 01:13:15+00:00
I don't think the bar here is a human level coder, I think the bar is an LLM which reads and follows the README.md.

If we're otherwise assuming it reads and follows an AGENTS.md file, then following the README.md should be within reach.

I think our task is to ensure that our README.md is suitable for any developer to onboard into the codebase. We can then measure our LLMs (and perhaps our own documentation) by if that guidance is followed.
by knome | 2025-08-20 01:14:10+00:00
It is hardly surprising that people don't bother differentiating between those that think they are inherently superior by dint of their race versus those that think others are innately inferior by dint of their race. The one implies the other. And those who would impose such views when met with counterexamples, with condescension, mockery, shunning, exclusion, and violence, are never so far behind.
Show HN: stagDB – Free and Open-Source database manager with instant branching
by aayush-kosh | 2025-08-20 01:15:22+00:00
While leading tech for a fintech org where we built out a relatively large and complex project in django and celery backed by postgres, we often came up with testing situations that needed real-world data to work with. We created an in-house hacked together version of what is now stagDB using only docker and zfs.

stagDB allows its user to create a database, load it with data to create a master, and then create as many clones as the underlying hardware may support.

This is still version 0.0.1 of the product. Feedback is welcome.
by iLemming | 2025-08-20 01:16:19+00:00
It is indisputably not a hobby, at least for me, personally it ain't. I've been coding long enough to see a difference between "oh, what a nice gimmick" and "how the fuck would I even do that, if I didn't know this way existed...". Long. My first programming language was Sinclair BASIC. The second PL I learned was Pascal. I picked up a few more over the years. I'm not trying to show off, nor am I claiming to be an outstanding programmer - I'm neither great nor terrible. I'm just saying I've been doing this shit for a long time, that's all.

It isn't a hobby, because Vim and Emacs allow me to perform in a way that I consider far more enjoyable, productive and satisfactory than I ever had before them. That is of course on a personal empirical basis - I cannot promise them having the same effect on anyone else.

In my opinion, after many years using many different tools, techniques, ideas and methodologies, frameworks, approaches, systems, platforms, workflows, philosophies, paradigms, strategies, practices, concepts, models, theories, and experiments, I personally find these two to be exactly the paradigm shift — in comparison to my prior experience when I didn't have them.

But let me be more specific - the paradigm shift I see is not in Emacs or Neovim as tools themselves. The paradigm shift I sense is in the grand ideas behind these tools - modal navigation and Lisp.

I honestly don't know why more people don't gravitate towards these ideas. Perhaps, because these ideas are kind of like 'meditation' - people say one can only experience the mind shift after practicing it for some time. I wouldn't know - I never practiced mediation for long. And that time required to see the shift can differ for every person - some may grok it quickly, for some, it may take decades without ever even clicking.

Also, you're wrong about "upgrading one's workshop" - it's a misconception that longtime Emacs users constantly have to tweak their configs. My config for example is pretty stable; I often make changes to it not because I have no choice, but because the task at hand calls for it. I write a lot of Lisp because it's an instrument for achieving specific goals and solving specific puzzles - work for which I get paid real amounts of real money. I get paid to use Emacs, not the opposite. So, no: definitely not a hobby.
by candiddevmike | 2025-08-20 01:17:35+00:00
RE: VSCode copilot, you're not crazy, I'm seeing it too. And across multiple machines, even with settings sync enabled, I have to periodically go on each one and uninstall the copilot extension _again_. I'll notice the Add to chat... in the right click context menu and immediately know it got reinstalled somehow.

I'd switch to VSCodium but I use the WSL and SSH extensions :(
by ameliaquining | 2025-08-20 01:17:45+00:00
README often contains only basic context for the project and instructions for basic tasks like running it and building it from source. If additional information for developers, like coding conventions, is short enough compared to the rest of the README then it sometimes gets added there too, but if there's a lot of it then it's frequently kept elsewhere to prevent README from getting overwhelming for end users and random people just checking out the project.
by nikvdp | 2025-08-20 01:18:17+00:00
I made a similar thing not long ago that lets you choose between docker, seatbelt (macOS's native sandboxing) and bubblewrap (on Linux).

I use it on macOS primarily, and have basically stopped using docker mode in favor of the native sandboxing because features like image pasting Just Work™.

http://github.com/nikvdp/cco
by yieldcrv | 2025-08-20 01:18:51+00:00
No rebuttals there

I think the previously hostile regulatory environment has caused a lot of innovation, that is more resilient and useful for capital formation, new sectors, industries. the cryptosecurities market in 2012 was really ghetto, the ICO market in 2017 was baaaad but working around securities regulations since registration+liquidity was impossible. 2024’s pump.fun should be for entertainment only, but it does standardize the token issuances in ways that werent there before

the bad stuff should be ignored by consumers or cleaned up

but at the end of the day it will always be up to consumers and investors to be more discerning, for critics to criticize bad organizations individually instead of indict all of crypto when something goes wrong. the lack of discernment allows for most bad actors to act with impunity, and encourages the ones that do eventually face consequence
by defrost | 2025-08-20 01:19:49+00:00
The stele itself is just one feature of an entire complex of caves, buildings, and artifacts dating back to ~ 400 CE (although largely ~ 1100 ish).

eg: The Library Cave, aka Cave 17, a trove of offline document c̶l̶o̶u̶d̶ cave storage.

https://en.wikipedia.org/wiki/Mogao_Caves
by faangguyindia | 2025-08-20 01:21:03+00:00
I am developing a coding agent that currently manages and indexes over 5,000 repositories. The agent's state is stored locally in a hidden `.agent` directory, which contains a configuration folder for different agent roles and their specific instructions. Then we've a "agents" folder with multiple files, each file has

<Role> <instruction>

Agent only reads the file if its role is defined there.

Inside project directory, we've a dot<coding agent name> folder where coding agents state is stored.

Our process kicks off with an `/init` command, which triggers a deep analysis of an entire repository. Instead of just indexing the raw code, the agent generates a high-level summary of its architecture and logic. These summaries appear in the editor as toggleable "ghost comments." They're a metadata layer, not part of the source code, so they are never committed in actual code. A sophisticated mapping system precisely links each summary annotation to the relevant lines of code.

This architecture is the solution to a problem we faced early on: running Retrieval-Augmented Generation (RAG) directly on source code never gave us the results we needed.

Our current system uses a hybrid search model. We use the AST for fast, literal lexical searches, while RAG is reserved for performing semantic searches on our high-level summaries. This makes all the difference. If you ask, "How does authentication work in this app?", a purely lexical search might only find functions containing the word `login` and functions/classes appearing in its call hierarchy. Our semantic search, however, queries the narrative-like summaries. It understands the entire authentication flow like it's reading a story, piecing together the plot points from different files to give you a complete picture.

It works like magic.
by db48x | 2025-08-20 01:21:23+00:00
This is a common misunderstanding about buffers. Buffers are the base primitive for text manipulation for a good reason; it’s a deliberate design decision not a handicap or a straitjacket. Think of a buffer as a string with a cursor in it, where it is always easy to manipulate the text at the cursor. (It’s implemented using a gap buffer <https://en.wikipedia.org/wiki/Gap_buffer>, but you don’t need to know that.)

The operations you can do on a buffer include not just the usual string primitives like insertion and deletion of text, but _any_ editing command that you could use as a user as well. For example, if you want to move the cursor to the beginning of the line, call `beginning-of-line`. This is exactly the same function that is bound to `C-a`. Want to move to the next line? That’s `next-line`, which is bound to the `down` key by default. Want to drop the mark at the cursor position? Call `set-mark`. Want to search for something? `re-search-forward`. Now that you’ve found what you were looking for, you want to remove it from the buffer? Call `kill-region`, same as if you had typed `C-w`.

And commands build on other, more primitive, commands to give you complex behaviors. There are commands for creating, parsing, and sending emails, making HTTP requests and parsing HTTP responses, creating and parsing JSON, XML or HTML, etc, etc. You can create some JSON in the current buffer, send it off to the server via HTTP, and when the response comes back it swaps you over to a new buffer with the response. Or you can ask it to parse the response and just give you the body, etc. Basically any command you could interactively use as an Emacs user will work as part of a new Elisp program simply by virtue of the fact that it works on the current buffer. And the new Elisp programs you write can be used as commands by the user, and as parts of the user’s next Elisp program.

And switching buffers it not slow; all the buffers are in memory at the same time and the “current” buffer is just a pointer. The only quirk is that the pointer is stored in a variable instead of being passed as an argument to every single command you run. And that’s a good thing, because you would soon get tired of passing the current buffer to every single function you call!
by asabla | 2025-08-20 01:23:12+00:00
Been using a similar setup, with so far pretty decent results. With the addition of having a short explanation for each file within index.md

I've been experimenting with having a rules.md file within each directory where I want a certain behavior. Example, let us say I have a directory with different kind of services like realtime-service.ts and queue-service.ts, I then have a rules.md file on the same level as they are.

This lets me scaffold things pretty fast when prompting by just referencing that file. The name is probably not the best tho.