frontpage.
newsnewestaskshowjobs

Made with ♥ by @iamnishanth

Open Source @Github

fp.

Migrating the main Zig repository from GitHub to Codeberg

https://ziglang.org/news/migrating-from-github-to-codeberg/
382•todsacerdoti•4h ago•265 comments

DIY NAS: 2026 Edition

https://blog.briancmoses.com/2025/11/diy-nas-2026-edition.html
92•sashk•3h ago•35 comments

Penpot: The Open-Source Figma

https://github.com/penpot/penpot
123•selvan•4h ago•15 comments

Voyager 1 is about to reach one light-day from Earth

https://scienceclock.com/voyager-1-is-about-to-reach-one-light-day-from-earth/
849•ashishgupta2209•16h ago•299 comments

Coq: The World's Best Macro Assembler? [pdf] [2013]

https://nickbenton.name/coqasm.pdf
29•addaon•1h ago•15 comments

Willis Whitfield: A simple man with a simple solution that changed the world

https://www.sandia.gov/labnews/2024/04/04/willis-whitfield-a-simple-man-with-a-simple-solution-th...
12•rbanffy•2d ago•0 comments

Running Unsupported iOS on Deprecated Devices

https://nyansatan.github.io/run-unsupported-ios/
116•OuterVale•7h ago•39 comments

Functional Data Structures and Algorithms: a Proof Assistant Approach

https://fdsa-book.net/
24•SchwKatze•4h ago•2 comments

S&box is now an open source game engine

https://sbox.game/news/update-25-11-26
268•MaximilianEmel•10h ago•91 comments

Gemini CLI Tips and Tricks for Agentic Coding

https://github.com/addyosmani/gemini-cli-tips
239•ayoisaiah•12h ago•80 comments

A Fast 64-Bit Date Algorithm (30–40% faster by counting dates backwards)

https://www.benjoffe.com/fast-date-64
301•benjoffe•4d ago•63 comments

C100 Developer Terminal

https://caligra.com/
56•matthewsinclair•7h ago•56 comments

Fara-7B: An efficient agentic model for computer use

https://github.com/microsoft/fara
109•maxloh•11h ago•34 comments

Bring bathroom doors back to hotels

https://bringbackdoors.com/
561•bariumbitmap•7h ago•436 comments

The EU made Apple adopt new Wi-Fi standards, and now Android can support AirDrop

https://arstechnica.com/gadgets/2025/11/the-eu-made-apple-adopt-new-wi-fi-standards-and-now-andro...
377•cyclecount•9h ago•174 comments

DSP 101 Part 1: An Introductory Course in DSP System Design

https://www.analog.com/en/resources/analog-dialogue/articles/dsp-101-part-1.html
27•teleforce•5h ago•0 comments

Comic Code Reviews

https://www.jona.ca/2025/11/comic-code-reviews.html
45•JonathanAquino•6d ago•24 comments

Ruby Was Ready from the Start

https://obie.medium.com/ruby-was-ready-from-the-start-4b089b17babb
37•thunderbong•2d ago•6 comments

A woman on a mission to photograph every species of hummingbird

https://www.audubon.org/magazine/meet-woman-mission-photograph-every-species-of-hummingbird-world
117•zeech•4d ago•21 comments

Making my 1970's-style renderer multi-threaded

https://filiph.net/text/making-my-1970s-renderer-multi-threaded.html
14•Apocryphon•3d ago•3 comments

Bonsai_term: A library for building dynamic terminal apps by Jane Street

https://github.com/janestreet/bonsai_term
18•azhenley•5h ago•4 comments

How Does Microwaving Grapes Create Plumes of Plasma?

https://www.pbs.org/wgbh/nova/article/how-does-microwaving-grapes-create-plumes-plasma/
42•wredcoll•3d ago•15 comments

A cell so minimal that it challenges definitions of life

https://www.quantamagazine.org/a-cell-so-minimal-that-it-challenges-definitions-of-life-20251124/
267•ibobev•20h ago•118 comments

Alan.app – Add a Border to macOS Active Window

https://tyler.io/2025/11/alan/
111•donatj•11h ago•65 comments

Show HN: Safe-NPM – only install packages that are +90 days old

https://github.com/kevinslin/safe-npm
68•kevinslin•3d ago•37 comments

Statistical Process Control in Python

https://timothyfraser.com/sigma/statistical-process-control-in-python.html
206•lifeisstillgood•21h ago•65 comments

Optery (YC W22) Hiring CISO, Release Manager, Tech Lead (Node), Full Stack Eng

https://www.optery.com/careers/
1•beyondd•13h ago

Show HN: I turned algae into a bio-altimeter and put it on a weather balloon

https://radi8.dev/blog/stratospore/
123•radeeyate•4d ago•11 comments

Cardiac implantable electronic devices' longevity: A novel modelling tool

https://journals.plos.org/plosone/article?id=10.1371/journal.pone.0333195
12•PaulHoule•4d ago•3 comments

Compressed filesystems à la language models

https://grohan.co/2025/11/25/llmfuse/
50•grohan•15h ago•8 comments
Open in hackernews

Coq: The World's Best Macro Assembler? [pdf] [2013]

https://nickbenton.name/coqasm.pdf
29•addaon•1h ago

Comments

throwaway198846•1h ago
They are going by Rocq today
AdieuToLogic•1h ago
The linked PDF was created on 8/5/13.
volemo•55m ago
Then the title needs (2013), no?
addaon•53m ago
Yep, sorry. Added.
volemo•56m ago
I understand and respect the renaming, Coq was a much cooler name though.
addaon•57m ago
Poster here. I re-read this paper about once a year. I continue to think that it may be one of the most important papers I've read. As someone who works on high-reliability safety-critical real-time systems (automotive, avionics), being able to work in an environment where I could prove semantic properties of assembly code is pretty close to my dream -- the cost of demonstrating code correct is already so much higher than the cost of writing the code that the incremental cost of going to assembly seems minor, if there's even a small payback in time to demonstrate correctness. In practice, I think my dream language would be a relatively rich macro assembler plus a (guided, greedy) register allocator, designed entirely to simplify and allow semantic proofs. I don't really have a sense as to whether Coq (Rocq) is the right answer today, vs other options; or if there's a newer literature advancing this approach; but I'd truly love to see a deeper focus of making low level languages more useful in this space, rather than moving towards more constrained, higher level languages.
kragen•47m ago
Have you found Coq or other formal-methods tooling useful?
addaon•40m ago
No, I haven't, but I want to. I haven't had the opportunity to go deep into formal methods for a work project yet, and on personal projects I've mostly played with Ada SPARK, not Coq. I've played with Coq a little (to the extent of re-implementing the linked paper for a subset of a different ISA), but there's definitely a learning curve. One of my personal benchmark projects is to implement a (fixed-maximum-size) MMM heap in a language, and convince myself it's both correct and of high performance; and I've yet to achieve that in any language, even SPARK, without leaning heavily on testing and hand-waving along with some amount of formal proof. I've written the code and comprehensive testing in various assembly languages (again, this is sort of my benchmark bring-up-a-new-platform-in-the-brain example), and I /think/ that for the way I think proving properties as invariants maintained across individual instructions maps pretty well to how I convince myself it's correct, but I haven't had the time, depth, or toolchain to really bottom any of this out.
quanto•42m ago
During the days I was studying/working with Coq, one visiting professor gave a presentation on defense software design. An example presented was control logic for F-16, which the professor presumably worked on. A student asked how do you prove "correctness", i.e. operability, of a jet fighter and its control logic? I don't think the professor had a satisfying answer.

My question is the same, albeit more technically refined. How do you prove the correctness of a numerical algorithm (operating on a quantized continuum) using type-theoretic/category-theoretic tools like theorem provers like Coq? There are documented tragedies where numerical rounding error of the control logic of a missile costed lives. I have proved mathematical theorems before (Curry-Howard!) but they were mathematical object driven (e.g. sets, groups) not continuous numbers.

dwohnitmok•32m ago
You use floating point numbers instead of real numbers in your theorems and function definitions.

This sounds flippant, but I'm being entirely earnest. It's a significantly larger pain because floating point numbers have some messy behavior, but the essential steps remain the same. I've proved theorems about floating point numbers, not reals. Although, again, it's a huge pain, and when I can get away with it I'd prefer to prove things with real numbers and assume magically they transfer to floating point. But if the situation demands it and you have the time and energy, it's perfectly fine to use Coq/Rocq or any other theorem prover to prove things directly about floating point arithmetic.

The article itself is talking about an approach sufficiently low level that you would be proving things about floating point numbers because you would have to be since it's all assembly!

But even at a higher level you can have theorems about floating point numbers. E.g. https://flocq.gitlabpages.inria.fr/

There's nothing category theoretic or even type theoretic about the entities you are trying to prove with the theorem prover. Type theory is merely the "implementation language" of the prover. (And even if there was there's nothing tying type theory or category theory to the real numbers and not to floats)

quanto•2m ago
> when I can get away with it I'd prefer to prove things with real numbers and assume magically they transfer to floating point.

True for some approaches, but numerical analysis does account for machine epsilon and truncation errors.

I am aware that Inria works with Coq as your link shows. However, the link itself does not answer my question. As a concrete example, how would you prove an implementation of a Kalman filter is correct?

quanto•54m ago
This paper reminds me of a class assignment in grad school where the prof asked the students to write a compiler in Coq for some toy Turning-complete language in a week. Having no background in compiler design or functional programming, I found it daunting at first, but eventually managed it. The Coq language's rigor really helps with something like this.

I wonder if AI's compute graph would benefit from a language-level rigor as of Coq.

kragen•48m ago
The canonical URL, dating back to at least 02015, may be http://research.microsoft.com/en-us/um/people/nick/coqasm.pd..., which now redirects to https://www.microsoft.com/en-us/research/publication/coq-wor.... This site presumably belongs to the Nick Benton who is one of its authors.
asdefghyk•46m ago
The x86 architecture and instruction set is complex - so it absolutely needs a powerful assembler to help prevent mistakes.
kragen•42m ago
That doesn't seem right to me. If the problem is that it has too many instructions and addressing modes, you can decide to only use a small subset of those instructions and addressing modes, which really isn't much of a handicap for implementing functionality. (It doesn't help with analyzing existing code, but neither does a powerful assembler.) I think that the reason that i386 assembly (or amd64 assembly) is error-prone is something else, something it has in common with very simple architectures and instruction sets like that of the PDP-8.