frontpage.
newsnewestaskshowjobs

Made with ♥ by @iamnishanth

Open Source @Github

fp.

The Rise of Spec Driven Development

https://www.dbreunig.com/2026/02/06/the-rise-of-spec-driven-development.html
1•Brajeshwar•3m ago•0 comments

The first good Raspberry Pi Laptop

https://www.jeffgeerling.com/blog/2026/the-first-good-raspberry-pi-laptop/
2•Brajeshwar•3m ago•0 comments

Seas to Rise Around the World – But Not in Greenland

https://e360.yale.edu/digest/greenland-sea-levels-fall
1•Brajeshwar•3m ago•0 comments

Will Future Generations Think We're Gross?

https://chillphysicsenjoyer.substack.com/p/will-future-generations-think-were
1•crescit_eundo•6m ago•0 comments

State Department will delete Xitter posts from before Trump returned to office

https://www.npr.org/2026/02/07/nx-s1-5704785/state-department-trump-posts-x
1•righthand•9m ago•0 comments

Show HN: Verifiable server roundtrip demo for a decision interruption system

https://github.com/veeduzyl-hue/decision-assistant-roundtrip-demo
1•veeduzyl•10m ago•0 comments

Impl Rust – Avro IDL Tool in Rust via Antlr

https://www.youtube.com/watch?v=vmKvw73V394
1•todsacerdoti•10m ago•0 comments

Stories from 25 Years of Software Development

https://susam.net/twenty-five-years-of-computing.html
2•vinhnx•11m ago•0 comments

minikeyvalue

https://github.com/commaai/minikeyvalue/tree/prod
3•tosh•16m ago•0 comments

Neomacs: GPU-accelerated Emacs with inline video, WebKit, and terminal via wgpu

https://github.com/eval-exec/neomacs
1•evalexec•21m ago•0 comments

Show HN: Moli P2P – An ephemeral, serverless image gallery (Rust and WebRTC)

https://moli-green.is/
2•ShinyaKoyano•25m ago•1 comments

How I grow my X presence?

https://www.reddit.com/r/GrowthHacking/s/UEc8pAl61b
2•m00dy•26m ago•0 comments

What's the cost of the most expensive Super Bowl ad slot?

https://ballparkguess.com/?id=5b98b1d3-5887-47b9-8a92-43be2ced674b
1•bkls•27m ago•0 comments

What if you just did a startup instead?

https://alexaraki.substack.com/p/what-if-you-just-did-a-startup
4•okaywriting•34m ago•0 comments

Hacking up your own shell completion (2020)

https://www.feltrac.co/environment/2020/01/18/build-your-own-shell-completion.html
2•todsacerdoti•37m ago•0 comments

Show HN: Gorse 0.5 – Open-source recommender system with visual workflow editor

https://github.com/gorse-io/gorse
1•zhenghaoz•37m ago•0 comments

GLM-OCR: Accurate × Fast × Comprehensive

https://github.com/zai-org/GLM-OCR
1•ms7892•38m ago•0 comments

Local Agent Bench: Test 11 small LLMs on tool-calling judgment, on CPU, no GPU

https://github.com/MikeVeerman/tool-calling-benchmark
1•MikeVeerman•39m ago•0 comments

Show HN: AboutMyProject – A public log for developer proof-of-work

https://aboutmyproject.com/
1•Raiplus•39m ago•0 comments

Expertise, AI and Work of Future [video]

https://www.youtube.com/watch?v=wsxWl9iT1XU
1•indiantinker•40m ago•0 comments

So Long to Cheap Books You Could Fit in Your Pocket

https://www.nytimes.com/2026/02/06/books/mass-market-paperback-books.html
3•pseudolus•40m ago•1 comments

PID Controller

https://en.wikipedia.org/wiki/Proportional%E2%80%93integral%E2%80%93derivative_controller
1•tosh•44m ago•0 comments

SpaceX Rocket Generates 100GW of Power, or 20% of US Electricity

https://twitter.com/AlecStapp/status/2019932764515234159
2•bkls•44m ago•0 comments

Kubernetes MCP Server

https://github.com/yindia/rootcause
1•yindia•45m ago•0 comments

I Built a Movie Recommendation Agent to Solve Movie Nights with My Wife

https://rokn.io/posts/building-movie-recommendation-agent
4•roknovosel•46m ago•0 comments

What were the first animals? The fierce sponge–jelly battle that just won't end

https://www.nature.com/articles/d41586-026-00238-z
2•beardyw•54m ago•0 comments

Sidestepping Evaluation Awareness and Anticipating Misalignment

https://alignment.openai.com/prod-evals/
1•taubek•54m ago•0 comments

OldMapsOnline

https://www.oldmapsonline.org/en
2•surprisetalk•56m ago•0 comments

What It's Like to Be a Worm

https://www.asimov.press/p/sentience
2•surprisetalk•56m ago•0 comments

Don't go to physics grad school and other cautionary tales

https://scottlocklin.wordpress.com/2025/12/19/dont-go-to-physics-grad-school-and-other-cautionary...
2•surprisetalk•56m ago•0 comments
Open in hackernews

Ask HN: How do robotics teams manage data and debugging today?

10•Lazaruscv•4mo ago
Hi HN,

I’m working on a project in the robotics space and would love to get the community’s perspective.

The problem I’ve seen: robotics teams generate a massive amount of data (ROS2, MCAP, OpenLABEL, etc.), but debugging and analysis often means hours of digging through logs, building custom scripts, or fighting fragmented formats. For small and medium robotics companies, this can really slow down iteration.

I’m trying to understand:

• How do you/your team currently manage and analyze robot data?

• What are the biggest pain points you face (e.g. debugging failures, comparing test runs, searching across logs)?

• Have you tried tools like Foxglove/Rerun/etc.? What works, what doesn’t?

• If there was a solution that actually made this easier, what would it have to do for you to adopt it?

I also put together a short (5 min) survey here: https://forms.gle/x57UReg8Yj9Gx7qZ8

If you’re willing to share your experiences in more detail, it would really help shape what we’re building.

We’ll anonymize responses and share the aggregated insights back with the community once we’ve collected enough.

Thanks in advance — I know this is a niche problem, but I figured HN has some of the sharpest robotics engineers, founders, and tinkerers out there. Really curious to hear how you’re solving this today.

Comments

dapperdrake•4mo ago
Am willing to help with this as well. The math can be iffy.
Lazaruscv•4mo ago
Really appreciate the offer, we’d love to take you up on it. A lot of what we’re exploring right now comes down to signal analysis and anomaly detection in robotics data, which gets math-heavy fast (especially when combining time-series data from multiple sources). We’re setting up short user interviews with roboticists/devs to better map the pain points. Would you be open to a quick chat about the trickiest math/log parsing issues you’ve faced? It could help us avoid reinventing the wheel.
msadowski•4mo ago
Full disclosure, I work at Foxglove right now. Before joining, I spent over seven years consulting and had more than 50 clients during that period. Here are some thoughts:

* Combing through the syslogs to find issues is an absolute nightmare, even more so if you are told that the machine broke at some point last night

* Even if you find the error, it's not necessarily when something broke; it could have happened way before, but you just discovered it because the system hit a state that required it

* If combing through syslog is hard, try rummaging through multiple mcap files by hand to see where a fault happened

* The hardware failing silently is a big PITA - this is especially true for things that read analog signals (think PLCs)

Many of the above issues can be solved with the right architecture or tooling, but often the teams I joined didn't have it, and lacked the capacity to develop it.

At Foxglove, we make it easy to aggregate and visualize the data and have some helper features (e.g., events, data loaders) that can speed up workflows. However, I would say that having good architecture, procedures, and an aligned team goes a long way in smoothing out troubleshooting, regardless of the tools.

Lazaruscv•4mo ago
This is super insightful, thank you for laying it out so clearly. Your point about the error surfacing way after it first occurred is exactly the sort of issue we’re interested in tackling. Foxglove is doing a great job with visualization and aggregation; what we’re thinking is more of a complementary diagnostic layer that:

• Correlates syslogs with mcap/bag file anomalies automatically

• Flags when a hardware failure might have begun (not just when it manifests)

• Surfaces probable root causes instead of leaving teams to manually chase timestamps

From your experience across 50+ clients, which do you think is the bigger timesink: data triage across multiple logs/files or interpreting what the signals actually mean once you’ve found them?

msadowski•4mo ago
In my case, it’s definitely the data triage. Once I see the signal, I usually have ideas on what’s happening but I’ve been doing this for 11 years.

Maybe there could be value in signal interpretation for purely software engineers but I reckon it would be hard for such team to build robots.

Lazaruscv•4mo ago
Our current thinking is to focus heavily on automating triage across syslogs and bag/mcap files, since that’s where the hours really get burned, even for experienced folks. For interpretation, we see it more as an assistive layer (e.g., surfacing “likely causes” or linking to past incidents), rather than trying to replace domain expertise.

Do you think there are specific triage workflows where even a small automation (say, correlating error timestamps across syslog and bag files) would save meaningful time?

msadowski•4mo ago
One thing that comes to mind is checking the timestamps across sensors and other topics. Two cases come to mind:

* I was setting up Ouster lidar to use gos time, don’t remember the details now but it was reporting the time ~32 seconds in the past (probably some leap seconds setting?)

* I had a ROS node misbehaving in some weird ways - it turned out there was a service call to insert something into db and for some reason the db started taking 5+ minutes to complete which wasn’t really appropriate for a blocking call

I think the timing is one thing that needs to be consistently done right on every platform. The other issues I came across were very application specific.

chfritz•4mo ago
This is something we are actively discussing in the Cloud Robotics Working Group right now. We've already had a number of sessions on this topic with various guest speakers. You can watch the recordings here: https://cloudroboticshub.github.io/meetings. Feel free to attend the upcoming meetings.
Lazaruscv•4mo ago
Thanks a lot for sharing this resource! I wasn’t aware of the Cloud Robotics Working Group, those sessions look super relevant. I’ll definitely check out the recordings and join future meetings. Our angle is very aligned: we’re exploring how AI/automation can help with the time sink of debugging large-scale ROS/ROS 2 systems, especially when logs/bag files pile up. It’d be valuable to hear what the community feels is still missing, even with the current set of tools. Do you think there’s space for a layer focused purely on automated error detection and root cause suggestions?
chfritz•4mo ago
"automated error detection" -- how do you want to do that? How would you define "error". Clearly you are not just proposing to detect "error" lines in the log, because that's trivial. But if you don't, then how would you define and detect errors and auto-root-cause them? Maybe we can discuss at one of the next meetings.
Lazaruscv•4mo ago
errors are rarely explicit in robots, they're often emergent from complex interactions, like a silent drift in AMCL localization causing a downstream collision, or sporadic packet loss in DDS causing desynchronized multirobot coordination. We'd describe errors dynamically through a mix of domain rules, unsupervised ML, and generative AI;

* Start with user-determined or auto-deduced invariants from "nominal" runs (e.g., "joint torque variance should never exceed 10% during unloaded motion," derived from historical MCAP bags). This takes inspiration from model-based verification techniques in current ROS2 research, e.g., automated formal verification with model driven engineering.

* use light, edge-optimized models (e.g., graph neural networks or variational autoencoders) to monitor ROS topic multivariate time series (/odom, /imu, /camera/image_raw). Fuse visual and sensor input using multimodal LLMs (fine-tuned on e.g. nuScenes or custom robot logs) to detect "silent failures" e.g., detect a LiDAR occlusion not reflected in logs but apparent from point cloud entropy spikes cross-checked against camera frames.

* Utilize GenAI (e.g., versions of GPT-4o or Llama) for NLP on logs, classifying ambiguous events like "nav stack increased latency" as a predictor for failure. This predictive approach is an improvement of the ROS Help Desk's GenAI model that already demonstrates 70-80% decrease in debugging time by indicating issues before full failure.

This is not hypothesizing; there are already PyTorch and ROS2 plugin prototype versions with ~90% accuracy detection in Gazebo simulation failures, and dynamic covariance compensation (as used in more recent AI-facilitated ROS2 localization studies) takes care of noisy real-world data.

The detection pipeline that is automatic will be akin to where the system receives live streams or bag files via a ROS2-compatible middleware (e.g., based on more recent flexible integration layers for task orchestration), then processes in streaming fashion then:

* map heterogeneous formats (MCAP, OpenLABEL, JSON logs) to a temporal knowledge graph nodes for components (sensors, planners), edges for causal dependencies and timestamps. Enables holistic analysis, as opposed to fragmented tools.

* Route the data through Apache Flink or Kafka combined ML pipelines for windowed detection. For instance, flag a "error" if a robot's velocity profile is beyond predicted physics models (with Control or PySDF libraries), even without explicit logs—combining environmental context from combined BIM/APS for vision use.

* subsequently employ uncertainty sampling through large language models to solicit user input on borderline scenarios, progressively fine‑tuning the models. Benchmark outcomes from SYSDIAGBENCH indicate that LLMs such as GPT‑4 perform exceptionally well, correctly identifying robotic problems in 85 % of cases across various model scales.

I trust this provides some insight; we are currently testing a prototype that fuses these components into a real‑time observability framework for ROS2. Although still in its infancy, it already demonstrates encouraging accuracy on both simulated and real‑world data sets. I would appreciate your thoughts on sharpening the notion of “error” for multi‑agent or hybrid systems, particularly in contexts where emergent behavior makes it hard to distinguish between anomalies and adaptive responses.

chfritz•4mo ago
Thanks for sharing! You've clearly done your homework. Can you contact me, e.g., on LinkedIn? I'd love to explore with you whether what you want to build could benefit from the open-source framework we've built for developing new full-stack robotic capabilities (Transitive, https://transitiverobotics.com/docs/learn/intro/).