krapht

If this is the only issue, can't this be addressed by normalizing the post-processed data before scoring? (that is, if it really is just a matter of block ordering)

Yes, and deep research was junk for the hard topics that I actually needed to sit down and research. Anything shallower I can usually reach by search engine use and scan; deep research saves me about 15-30 minutes for well-covered topics.

For the hard topics, the solution is still the same as pre-AI - search for popular survey papers, then start crawling through the citation network and keeping notes. The LLM output had no idea of what was actually impactful vs what was a junk paper in the niche topic I was interested in so I had no other alternative than quality time with Google Scholar.

We are a long way from deep research even approaching a well-written survey paper written by grad student sweat and tears.

HIP is something you can put in production and Zluda is a proof-of-concept?

Of libraries that are better than the STL? Or data structures that the STL is missing? Without getting into the weeds of esoteric data structures and algorithms I think there's a few holes that aren't addressed:

https://github.com/martinus/unordered_dense provides better replacements for unordered_map/set.

The STL is missing B-trees and B-heaps, as well as d-heaps.

STL is also missing a radix sort, which is even more sorely missed now that we have std::executor::par_unseq to play with.

So the MI300x has 8 different memory domains, and although you can treat it as one flat memory space, if you want to reach their advertised peak memory bandwidth you have to work with it like an 8-socket board.

Why should there be HoTT, though?

A lot less work has gone into making HoTT theorem provers ergonomic to use. Also, the documentation is a lot more sparse. The benefits of HoTT are also unclear - it seems to only save work when dealing with very esoteric constructs in category theory.

Certainly not for introductory courses. There's already too much on the table - how to prove, how to program, and the base material itself.

I believe that's the experience of faculty who've tried as well - it's fine for advanced students, but a waste of instructional time for the average pupil.

https://docs.python.org/3/tutorial/floatingpoint.html

Stop at any finite number of bits, and you get an approximation. On most machines today, floats are approximated using a binary fraction with the numerator using the first 53 bits starting with the most significant bit and with the denominator as a power of two. In the case of 1/10, the binary fraction is 3602879701896397 / 2 * 55 which is close to but not exactly equal to the true value of 1/10.

Many users are not aware of the approximation because of the way values are displayed. Python only prints a decimal approximation to the true decimal value of the binary approximation stored by the machine. On most machines, if Python were to print the true decimal value of the binary approximation stored for 0.1, it would have to display:

  0.1
  0.1000000000000000055511151231257827021181583404541015625

That is more digits than most people find useful, so Python keeps the number of digits manageable by displaying a rounded value instead:

  1 / 10
  0.1

That being said, double should be fine unless you're aggregating trillions of low cost transactions. (API calls?)

I agree, and yet here we are. If it wasn't built with automake I would even consider getting wheels built on the projects behalf, but I can't make heads or tails of M4.

EDIT: But let's not pretend getting cibuildwheel going for every supported variant of PythonMajVer/OS/(32/64) bit is an easy lift for small open source projects. Conda is still more ergonomic than this, although it's slowly dying because big projects have the manpower to stand up and maintain the CI pipeline for PyPI, so Conda is less and less necessary.

Conda is still the recommended way to work with Intel's Python distribution, so there's a reason for it to live on my work computer.

The fastest graph library I know, graph-tool, needs to be installed with Conda too.

I tried to give Nix a chance but I never figured out how to package dependencies that didn't already have a derivation written for them.

Particularly since I do a lot of ML work - I never figured out how to handle mixed Python/C++ code with dependencies on CUDA.

It's just way easier, even if not reproducible, to build an environment imperatively in Docker.

Because I benchmarked both on my dataset and found that Tesseract was better for my use-case?

Because the VLM doesn't know it hallucinated. When you get a Tesseract error you can flag the OCR job for manual review.

I just built a pipeline with tesseract last year. What's better that is open source and runnable locally?

VLLM hallucination is a blocker for my use case.

It is nicer, but that interface latency would turn me off. When I search for online groceries, I want simple queries e.g spinach to return varieties (e.g frozen, fresh, and canned) of spinach as fast as possible.

I know you're going to reply with "BUT MY PREPROCESSOR", but template specialization is a big win and improvement (see qsort vs std::sort).

The article title is half-true. It wasn't so much they migrated away from Rust, but that they migrated away from Bevy, which is an alpha quality game engine.

I wouldn't have read the article if it'd been labeled that, so kudos to the blog writer, I guess.

I'm only familiar with C++, Python, and SQL. Neither GDB nor PDB helps here, and I've never heard of a SQL debugger that will break apart expressions and let you view intermediate query results.

Yes, but here's my hot take - what if you didn't have to edit the source code to debug it? Instead of chaining method calls you just assign to a temporary variable. Then you can set breakpoints and inspect variable values like you do normally without editing source.

It's not like you lose that much readability from

  foo(bar(baz(c)))

  c |> baz |> bar |> foo

  c.baz().bar().foo()

  t = c.baz()
  t = t.bar()
  t = t.foo()

Hackers are not crackers.

Is this similar to what 2, 4 dinitrophenol affects?

It's so rare to see work at this level posted online. RF experimentation isn't as popular as it used to be. I enjoyed this article!

Big combinatorial problems still use genetic algorithms. Specifically I know it's still used for logistics routing problems that are too big for solvers like Gurobi.

Deep learning on graphs is unfortunately still a little underwhelming.

I agree that the US bears significant responsibility for the ~5% civilian deaths in Iraq. These were through:

1) Direct combat fatalities (~15% of casualties)

2) Failing to stabilize Iraq post-invasion

3) Enabling conditions for prolonged conflict

However, attributing all excess deaths solely to the US oversimplifies the role of insurgent groups, regional actors, and preexisting sectarian tensions. The invasion’s destabilizing effects created a chain reaction with shared accountability.

Furthermore, calling it murder is disingenuous. Murder requires both premeditation and deliberate intent.

I had thought for awhile to learn Modelica, but the opportunity to use it in a project never came up. More specialized tools were always easier to use - Simulink, or SPICE for electrical circuits.

That correspondence doesn't automatically mean you get a useful compiler from proofs. Rather, that's the exception instead of the rule.

I'd like to see proof that Medicare does not evaluate QALY and spends unlimited money in general.

On that note I've been meaning to explore Wuffs for this problem.

https://github.com/google/wuffs

> Edit: Also, side note, why are so many people running their LLMs in the cloud? All the cutting edge models are open weight licensed, and run locally. You don't need to depend on some corporation that will inevitably rug-pull you.

???

Deepseek R1 doesn't run locally unless you program on a dual socket server with 1 TB of RAM. Or enough cash to have a cabinet of GPUs. The trend for state-of-the-art LLMs is to get bigger over time, not smaller.

Look, I've played with llava and llama locally too, but the benchmarked performance is nowhere near what you can get from the larger cloud providers who can serve hundred-million+ parameter models without quantization.

It's really easy when you can talk to living people today who experienced the ussr in the 80s and compare to the average Western experience at the same time.