frontpage.
newsnewestaskshowjobs

Made with ♥ by @iamnishanth

Open Source @Github

fp.

Show HN: LocalGPT – A local-first AI assistant in Rust with persistent memory

https://github.com/localgpt-app/localgpt
143•yi_wang•5h ago•43 comments

Haskell for all: Beyond agentic coding

https://haskellforall.com/2026/02/beyond-agentic-coding
62•RebelPotato•4h ago•16 comments

Bye Bye Humanity: The Potential AMOC Collapse

https://thatjoescott.com/2026/02/03/bye-bye-humanity-the-potential-amoc-collapse/
47•rolph•3h ago•31 comments

SectorC: A C Compiler in 512 bytes (2023)

https://xorvoid.com/sectorc.html
258•valyala•12h ago•51 comments

Total surface area required to fuel the world with solar (2009)

https://landartgenerator.org/blagi/archives/127
26•robtherobber•4d ago•20 comments

Speed up responses with fast mode

https://code.claude.com/docs/en/fast-mode
168•surprisetalk•12h ago•159 comments

Software factories and the agentic moment

https://factory.strongdm.ai/
202•mellosouls•15h ago•354 comments

LLMs as the new high level language

https://federicopereiro.com/llm-high/
69•swah•4d ago•123 comments

Brookhaven Lab's RHIC concludes 25-year run with final collisions

https://www.hpcwire.com/off-the-wire/brookhaven-labs-rhic-concludes-25-year-run-with-final-collis...
73•gnufx•11h ago•59 comments

Hoot: Scheme on WebAssembly

https://www.spritely.institute/hoot/
181•AlexeyBrin•18h ago•35 comments

Stories from 25 Years of Software Development

https://susam.net/twenty-five-years-of-computing.html
172•vinhnx•15h ago•17 comments

Vocal Guide – belt sing without killing yourself

https://jesperordrup.github.io/vocal-guide/
322•jesperordrup•22h ago•97 comments

First Proof

https://arxiv.org/abs/2602.05192
135•samasblack•15h ago•80 comments

Why there is no official statement from Substack about the data leak

https://techcrunch.com/2026/02/05/substack-confirms-data-breach-affecting-email-addresses-and-pho...
20•witnessme•1h ago•6 comments

Vouch

https://twitter.com/mitchellh/status/2020252149117313349
72•chwtutha•3h ago•16 comments

Wood Gas Vehicles: Firewood in the Fuel Tank (2010)

https://solar.lowtechmagazine.com/2010/01/wood-gas-vehicles-firewood-in-the-fuel-tank/
32•Rygian•2d ago•8 comments

Show HN: I saw this cool navigation reveal, so I made a simple HTML+CSS version

https://github.com/Momciloo/fun-with-clip-path
83•momciloo•12h ago•17 comments

Al Lowe on model trains, funny deaths and working with Disney

https://spillhistorie.no/2026/02/06/interview-with-sierra-veteran-al-lowe/
105•thelok•14h ago•24 comments

Start all of your commands with a comma (2009)

https://rhodesmill.org/brandon/2009/commands-with-comma/
585•theblazehen•3d ago•212 comments

Show HN: A luma dependent chroma compression algorithm (image compression)

https://www.bitsnbites.eu/a-spatial-domain-variable-block-size-luma-dependent-chroma-compression-...
40•mbitsnbites•3d ago•5 comments

FDA intends to take action against non-FDA-approved GLP-1 drugs

https://www.fda.gov/news-events/press-announcements/fda-intends-take-action-against-non-fda-appro...
112•randycupertino•8h ago•238 comments

The AI boom is causing shortages everywhere else

https://www.washingtonpost.com/technology/2026/02/07/ai-spending-economy-shortages/
309•1vuio0pswjnm7•19h ago•491 comments

Learning from context is harder than we thought

https://hy.tencent.com/research/100025?langVersion=en
233•limoce•4d ago•125 comments

Where did all the starships go?

https://www.datawrapper.de/blog/science-fiction-decline
156•speckx•4d ago•242 comments

OpenCiv3: Open-source, cross-platform reimagining of Civilization III

https://openciv3.org/
904•klaussilveira•1d ago•276 comments

Microsoft account bugs locked me out of Notepad – Are thin clients ruining PCs?

https://www.windowscentral.com/microsoft/windows-11/windows-locked-me-out-of-notepad-is-the-thin-...
147•josephcsible•10h ago•182 comments

Selection rather than prediction

https://voratiq.com/blog/selection-rather-than-prediction/
35•languid-photic•4d ago•16 comments

Show HN: Look Ma, No Linux: Shell, App Installer, Vi, Cc on ESP32-S3 / BreezyBox

https://github.com/valdanylchuk/breezydemo
304•isitcontent•1d ago•39 comments

I write games in C (yes, C) (2016)

https://jonathanwhiting.com/writing/blog/games_in_c/
189•valyala•12h ago•179 comments

An Update on Heroku

https://www.heroku.com/blog/an-update-on-heroku/
496•lstoll•1d ago•331 comments
Open in hackernews

An illustrated guide to automatic sparse differentiation

https://iclr-blogposts.github.io/2025/blog/sparse-autodiff/
137•mariuz•9mo ago

Comments

nathan_douglas•9mo ago
Picking my way through this slowly... I'm familiar with autodiff but some of these ideas are very new to me. This seems really, really exciting though.
whitten•9mo ago
This paper is written by three Europeans who clearly understand these mathematical ideas.

Is this type of analysis a part of a particular mathematical heritage ?

What would it be called ?

Is this article relevant ? https://medium.com/@lobosi/calculus-for-machine-learning-jac...

ghurtado•9mo ago
I quickly realized it was approximately 20,000 ft over my head, but I still power through these sort of things to see if anything "sticks".

So far, nothing but I'll keep trying ..

molticrystal•9mo ago
Maybe someone else can summarize more accurately or do a better job but I'll take a shot:

The Jacobian often appears in the final segment of a three part calculus series when exploring chain rules and variable transformations. Look up the Jacobian used in converting between x,y,z and spherical coordinates ρ,φ,θ and note its matrix structure. Skimming your Medium Lobosi article it seems it emphasizes this aspect.

The Jacobian also serves another purpose. As stated in the OP's article "The Jacobian operator Df:x⟼Df(x) is a linear map which provides the best linear approximation of f around a given point x."

We like approximations, we can make a speed vs accuracy/memory trade off, you only have so much space in a register or memory cell, and trying to get more accuracy past a certain point takes more memory/computations/time.

The article then notes that many computations involve Jacobians with sparse matrices meaning some matrix elements can be ignored so we don't have to waste our time on them if handled cleverly.

Subsequent sections cover methods to identify and label sparsity patterns. The article explains how applying their proposed coloring techniques to large matrices common in machine learning yields significant efficiency gains.

As far as the mathematical heritage, I don't know the family tree, but I suspect it stems from courses blending matrix theory linear algebra and algorithms so you'd want the computer science version of such math. Functional approximation ties to numerical methods though I am uncertain if introductory texts cover Jacobians. Check out Newton's method to grasp its mechanics and understand how that works then explore its Jacobian extension. For the coloring aspect graph theory is where to turn. You can learn its basics with minimal prerequisites by studying the seven bridges problem or the map coloring problem, do the five color version. Many of these concepts can be simplified into small programming projects. They will not rival Matlab but they will solidify your understanding.

yorwba•9mo ago
The blog post mentions in an aside that "The authors of this blog post are all developers of the ASD ecosystem in Julia." which might be the closest thing to an intellectual school that this kind of work is associated with.
gdalle•9mo ago
Blog post author here, happy to answer any questions you may have!

The prerequisites for understanding the blog post are an undergrad course in calculus and linear algebra, and some graph theory. I can look up some accessible resources if you're interested :)

JohnKemeny•9mo ago
Does this article exist as a (LaTeX) pdf for printing too?
funks_•9mo ago
We don’t have plans for that, but you could try to convert the Markdown source: https://github.com/iclr-blogposts/2025/blob/main/_posts/2025...
gdalle•9mo ago
Our Arxiv preprint is a slightly longer read, available in PDF form with more precise descriptions: https://arxiv.org/abs/2501.17737
carterschonwald•9mo ago
Thx!

It’s always fun to see new flavors of AD work. My attempts in that direction haven’t been the most successful

constantcrying•9mo ago
>Is this type of analysis a part of a particular mathematical heritage ?

It is a mixture of two very much related areas of mathematics. Analysis, called calculus in the US, and numerics.

The ideas behind automatic differentiation arise from the question of how to compute the derivative of a function on a computer. The "derivative" part is the Analysis part and the "on a computer" part is the numerics.

As it turns out writing down the formal definition of the derivative and approximating it on a computer has many undesirable properties. So alternative approaches, like AD, were developed. But AD is much older than the recent Neural network trend.

imtringued•9mo ago
The hessian is needed for optimization and this blog post was most likely motivated by improving the method used in the precursor blog post: https://iclr-blogposts.github.io/2024/blog/bench-hvp/
funks_•9mo ago
Yes, this blog post indeed inspired us to submit ours!
rdyro•9mo ago
A really cool post and a great set of visualizations!

Computing sparse Jacobians can save a lot of compute if there's a real lack of dependency between part of the input and the output. Discovering this automatically through coloring is very appealing.

Another alternative is to implement sparse rules for each operation yourself, but that often requires custom autodiff implementations which aren't easy to get right, I wrote a small toy version of a sparse rules-based autodiff here: https://github.com/rdyro/SpAutoDiff.jl

Another example (a much more serious one) is https://github.com/microsoft/folx

gdalle•9mo ago
You might also be interested in Spadina for Enzyme. There are no Julia bindings yet but I’d be excited if someone made them! https://c.wsmoses.com/presentations/weuroad23.pdf
oulipo•9mo ago
Sparsely-related question: is the blog style/css open-source?
molticrystal•9mo ago
It seems to be based off of Al-Folio, MIT licensed

https://github.com/alshedivat/al-folio

FilosofumRex•9mo ago
The classic reference on the subject is "Numerical Linear Algebra" by Lloyd Trefethen. Skip to the last chapter on the iterative methods for computational aspects. You'll learn a lot more and faster with Matlab.

https://davidtabora.wordpress.com/wp-content/uploads/2015/01...

A short overview is chapter 11 in Gilbert Strangs's Intro to linear Algebra https://math.mit.edu/~gs/linearalgebra/ila5/linearalgebra5_1...

AD comes from a different tradition - dating back to FORTRAN 77 programers attempt to differentiate non-elementary functions (For Loops, procedural functions, Subroutines, etc). Note the hardware specs for some nostalgia https://www.mcs.anl.gov/research/projects/adifor/

gwf•9mo ago
Not trying to "Schmidhuber" this or anything, but I think my 1999 NIPS paper gives a cleaner derivation and explanation for working on the Jacobian. In it, I derive a Jacobian operator that allows you to compute arbitrary products between the Jacobian and any vector, with complexity that is comparable to standard backprop.

[*] G.W. Flake & B.A. Pearlmutter, "Differentiating Functions of the Jacobian with Respect to the Weights," https://proceedings.neurips.cc/paper_files/paper/1999/file/b...

goosedragons•9mo ago
There is automatic sparse differentiation available in the R ecosystem. That's what the RTMB & TMB packages do.
adgjlsfhk1•9mo ago
That's really impressive! I can't even imagine implimenting sparsity tracing in a language as dynamic and hard to compile as R.
goosedragons•9mo ago
I think they do sparsity tracing and tape construction in C++ behind the scenes. RTMB does some wacky thing abusing complex values to let you write the function code in R and pass that off somehow.
patrick451•9mo ago
The optimal control framework Casadi has had the ability to compute sparse jacobians and hessians for a long time (maybe a decade?), which come up all the time in trajectory optimization.This not only provides massive speed ups in both the differentiation and linear solver time, but also greatly reduces the memory requirements. If this catches on in machine learning, it will be interesting to see if we can finally move past first order optimization methods.
gdalle•9mo ago
Indeed, CasADi is among the precursors in this area! The key difference with our approach is their use of a domain-specific language, with distinct mathematical functions and array types. This has lots of benefits, but it expects users to rewrite their existing code in the CasADi formalism. What we seek to achieve in Julia is compatibility with native code, without a DSL-imposed refactor. We share this ambition with the broader Julia autodiff ecosystem, which is focused on differentiating the language as a whole. Of course it doesn't always work, but in many cases, it enables a plug-and-play approach to (sparse) autodiff which makes really cool applications possible.