heisenzombie

First up, I agree that mathematical pedagogy is usually pretty rough, more or less from Kindergarten to Postdoc.

But, this article implicitly assumes that a mathematical proof has to be utterly rigorous in order to be useful. I would assume that the author leans hard towards a "formalist" view of mathematics. I think this is an insufficient understanding of what mathematics _is_ and that embracing some amount of mathematical platonism and using "incomplete" proofs to gesture at important understandings is necessarily a valuable part of mathematical pedagogy.

My opinion is basically that of David Bessis, see a recent blog post [1], and his excellent book on the subject [2].

[1] https://davidbessis.substack.com/p/the-curious-case-of-broke...

[2] https://www.goodreads.com/en/book/show/200128457-mathematica

I suspect the diaresis was intentional, in “New Yorker” style.

https://www.arrantpedantry.com/2020/03/24/umlauts-diaereses-...

It bears really thinking through the alternative:

So we're going to have some engineers specify suitable digital replacements given the process/environment/safety requirements. We'll procure those (noting that an industrial digital pressure transducer can easily push up towards $10k), schedule a plant shutdown (how much does that cost?), then pay a pipefitter/boilermaker to replace the old gauges with new pressure transmitters (do you need a hot work permit for that? Did you get your engineer to sign that off?). Then, your controls sparky has to find a way to route a drop back to your marshalling cabinet for connection into your fieldbus/HART/modbus/whatever network (do you have one of those?) so that your SCADA system can talk to it (do you have one of those?).

Obviously it's not really an apples-to-apples comparison, but I think the costs involved with making "simple" changes in industrial settings are easy to wildly underestimate.

I did (using Claude Code) something that sounds very similar to this. It’s a bunch of bootstrapped Unix tools, systemd units, and some markdown files. Two comments:

- I suspect that in this moment, cobbling together your own simple version of a “claw-alike” is far more likely to be productive than a “real” claw. These are still pretty complex systems! And if you don’t have good mental models of what they’re doing under the hood and why, they’re very likely to fail in surprising, infuriating, or downright dangerous ways.

For example, I have implemented my own “sleep” context compaction process and while I’m certain there are objectively better implementations of it than mine… My one is legible to me and therefore I can predict with some accuracy how my productivity tamagotchi will behave day-to-day in a way that I could not if I wasn’t involved in creating it.

(Nb I expect this is a temporary state of affairs while the quality gap between homemade and “professional” just isn’t that big)

- I do use mine as a personal assistant, and I think there is a lot of potential value in this category for people like me with ADD-style brains. For whatever reason, explaining in some detail how a task should be done is often much easier for me than just doing the task (even if, objectively, there’s equal or higher effort required for the former). It therefore doesn’t do anything I _couldn’t_ do myself. But it does do stuff I _wouldn’t_ do on my own.

Jax is super fun to use outside of ml!

Recently I had fun reimplementing an old (but still usable!) code for accelerator optics. It involved transfer matrices for a 6D phase space to second order. Most of the FORTRAN77 source code was just pages and pages of hand-differentiated 6x6x6 matrices (with quite non-trivial elements) and the plumbing to painstakingly propagate those jacobians around for fitting... all replaced with a single, magic, call to jax.grad(). Felt like cheating!

I'm also super interested in its application to modelling, e.g. projects like https://github.com/deepmodeling/jax-fem -- particularly for chaining different sorts of simulations and analysis together and getting gradients through the lot. Also quite magic!

Well nothing, I think what is being proposed is to trigger existing capital gains taxes when an asset is borrowed against, the same as if it were sold. Most places exempt personal homes from capital gains taxes already, so it wouldn’t affect them. It would affect

- someone who bought an investment property, which then appreciated, and then they wanted to take out a larger mortgage against the appreciated value to leverage it into buying another property.

- Someone borrowing against stock to avoid realising gains by selling it

That seems… reasonable to me?

I was under the impression that everyone (ie US, UN, EU) basically agreed they complied with the JCPOA right up until the US pulled out of it? Is that not accurate?

In Australia it's the board of directors who are liable. They can be liable if they personally direct the company to do something illegal (obviously?) but there is also a positive obligation to exercise due diligence. This covers (but is not limited to) workplace safety and safety of customers and the public. Directors can be personally liable for breaches of this duty and the penalties extend to possible imprisonment and very substantial fines.

For example: https://www.owhsp.qld.gov.au/court-report/fines-imposed-fail...

Another irony is that I clicked on one of their suggested questions ("My aging parent lives alone...") and the first part of the answer was:

""" 1. Explore Government and Community Meal Programs (Often Low-Cost or Free) Many programs provide balanced, home-delivered meals designed for seniors, emphasizing nutrition over processed frozen dinners. These are ideal for someone on a fixed income who doesn't cook. """

Specifically, it recommended Meals on Wheels, the Commodity Supplemental Food Program (CSFP), Local senior food pantries or boxes through Feeding America food banks, and Medicare Advantage or Medicaid benefits.

To my obvious follow-up question, Grok replied "Yes, several of these programs have faced proposed cuts, eliminations, or other pressures during the current Trump administration"

I have Copilot buttons sprinkled everywhere on my work computer, and every time I have tried to use them I get something saying "Oh, I can't do that". It's truly baffling.

Copilot button on my email inbox? I try "Find me emails about suchandsuch", and get the response "I don’t have direct access to your email account. If you’re using Outlook (desktop, web, or mobile), here are quick ways to find all emails related to...". Great, so it doesn't even know what program it's runnning in, let alone having any ability to do stuff in there! Sigh.

The idea is good, but juv is a one-jupyter-per-notebook model which isn't very practical for how my team uses jupyter. My attempt at "juv, but systemwide-jupyter-plus-one-kernel-per-notebook model" is this: https://github.com/tobinjones/uvkernel

“PrettyFlyForAWiFi”

Climate scientists have been correctly predicting the future for 50 years:

https://agupubs.onlinelibrary.wiley.com/doi/10.1029/2019GL08...

"Retrospectively comparing future model projections to observations provides a robust and independent test of model skill. Here we analyze the performance of climate models published between 1970 and 2007 in projecting future global mean surface temperature (GMST) changes..."

I also was impressed at Chris Borge's lathe build:

https://www.youtube.com/watch?v=6Js8erWbsDQ

It's small and kind of underpowered, but not useless! The central idea is to 3D print shells that hold metal parts and are then filled with concrete for rigidity and mass. Quite clever, I think.

I'll second the plug for structured concurrency (and specifically the Trio [1] library that the author wrote.

[1] https://github.com/python-trio/trio

Yes. Others have pointed out the shortcuts in iOS and macOS. For Windows—I have Alt-0151 in muscle memory.

Quick plug here for a simple Jupyter kernel I created:

https://github.com/tobinjones/uvkernel

It’s a pretty minimal wrapper around “uv” and “iPython” to provide the functionality from the article, but for Jupyter notebooks. It’s similar to other projects, but I think my implementation is the least intrusive and a good “citizen” of the Jupyter ecosystem.

There’s also this work-in-progress:

https://github.com/tobinjones/pep723widget

Which provides a companion Jupyter plugin to manage the embedded script dependencies of noteboooks with a UI. Warning — this one is partially vibe-coded and very early days.

This seems right to me. I often ask questions in two phases to take advantage of this (1) How would a professional in the field ask this question? Then (2) paste that question into a new chat.

No I had the same reaction. This kind of rigid "semantic network" kind of approach just can't work in the absolute case. And the author seems quite "absolute" about it.

It comes down to - what's the point of this? If it's to prove theorems to a computer then it's obviously the wrong approach. If it's to explain concepts to humans then it's _also_ the wrong approach. It's not true in any useful way that one can learn something by just starting at a random "node" and then "tree shaking" some big "knowledge graph" and just learning the specific edges that remain.

That said, no hate for this kind of tool! Interlinked knowledge is obviously great and useful, it's the emphasis on designing a rigid ontology that makes me raise an eyebrow.

<man walks into sauna room> Ooh, it's a bit hot in here! I better throw some water on these rocks to cool them down.

Joking aside, I actually don't know how dry it is in the underground, and therefore whether adding water for evaporative cooling would work. I would have assumed it was quite humid, but maybe not?

Hm, I haven't had any luck making this work. Have opened an issue.

I have been thinking about this for months now! Very excited to see you've implemented it, and I'm excited to try this out.

Could be fantastic for my use-case. We have a large repo of notebooks that are generally write-once, sometimes-re-run. Having a separate repo/venv/kernel per notebook would be a big overhead, so I currently just try to do a kind of semantic versioning where I make a new kernel on something like a 6-month cadence and try to keep breaking dependency changes to a minimum in that window. I can then keep around the old kernels for running old notebooks that depend on them. This is not at all an ideal state.

Thanks for sharing!

I understand the audiobook server, but what’s the use case for the podcast part? You replicate a podcast on your own server, in case the original goes away?

My experience is that SOTA LLMs still struggle to read even the metadata from a mechanical drawing. They're getting better -- they now are mostly ok at reading things like a BOM or revision table -- but moderately complicated title blocks often trip them up.

As for the drawings themselves, I have found them pretty unreliable at reading even quite simple things (i.e. what's the ID of the thru hole?), even when they're specifically dimensioned. As soon as spatial reasoning is required (i.e. there's a dimension from A to B and from A to C and one asks for the dimension B to C), they basically never get it right.

This is a place where there's a LOT of room for improvement.

He seems reasonably explicit about this:

""

This means that when using polynomial features, the data must be normalized to lie in an interval. It can be done using min-max scaling, computing empirical quantiles, or passing the feature through a sigmoid. But we should avoid the use of polynomials on raw un-normalized features.

""

Yes, perhaps I wasn’t clear — I’m advocating for just the inlined version, not the nested function in the general case.

The nested function is, I think, fine when it’s so tiny it’s not worth unit testing (like, it-could-have-been-a-lambda small) or when bar is returned by foo (ie foo is higher order), in which case you can test the return value. Apart from that… restraint!

If you want a function that's private to a function in Python you _could_ also do:

    def foo(context):
    
        def bar(x):
            return x*2
        
        baz = bar(context)

But if you have functions that only need to be called from one calling function then I why not just inline the code and eschew having a function at all. Long function bodies for the win!

You can definitely make ginger beer with wild yeast (fresh ginger root conveniently comes with lots of wild yeasts) and make delicious drinks. There are lots of recipes.

I also recommend, if anyone is interested, investigating “ginger beer plant” (GBP), which is a symbiotic culture of bacteria and yeasts (SCOBY) such as that used to brew kombucha and kefir. It was once common in Britain, but almost went extinct. Some was saved by a German culture bank (DSMZ), and now you can buy some online! Makes a different, and I think delicious, drink compared to the “ginger bug” method!

If you’ve got some money,

https://www.comsol.com/blogs/6-examples-of-simulation-driven...

Those examples wouldn’t be differentiable in the sense of automatic differentiation. “Just” parametric CAD + FEM/BEM + optimizer.

Though differentiable FEM has kind of been done for a while under the name “adjoint method” for topology/shape optimization. It’s not super common outside of academia though.

Personally, I’m keeping an eye out for projects like https://github.com/deepmodeling/jax-fem to make some waves in that space.

Something can be “a book” on the subject, or “the book” on the subject in the sense of the one commonly accepted authoritative reference. I read the above as referring to those two senses respectively.