waldrews

Great speed scores, reasonable SEO and best-practices scores, a few accessibility-related nitpicks but none critical. So, better than most professionals.

https://pagespeed.web.dev/analysis/https-naya-lol/tkn3le4d53

There are a few magical algorithms/systems which give you superpowers if you can find the right application for them. At least in the pre-LLM era, they were some of the magical tools we had, for just solving declaratively specified difficult problems without us explicitly writing code, while (unlike certain AI techniques which shall remain nameless) providing correctness guarantees and often being deterministic and stable.

Prolog and logic programming is one, together with its relative, constraint logic programming, and its relative mixed integer programming, which in turn is part of the broader linear and convex programming family.

What else should we put in that category?

Yes please. When we torture students with seemingly archaic math, like geometry largely in the form it was in the time of Euclid, we do it for a reason, setting up subsequent ideas, and we have modern textbooks that clean up the presentation and connect it to modern applications.

Making students learn an outdated form of English, useful for Shakespeare and nothing else, does not seem that useful as an investment of effort, compared with learning another modern language, or even something like Latin that in turn helps in learning other languages and understanding English vocabulary in several useful fields.

Growing up reading Shakespeare in the original Klingon, being able to actually understand what was going on, gave me more of an appreciation of the literature/stories/history than later struggling through it in archaic English with a reference in hand.

Repeal the Second Law! Free Energy for Everyone!

It's a classic application of the pigeonhole principle, the first on in this list:

https://en.wikipedia.org/wiki/Pigeonhole_principle#Uses_and_...

No invertible function can map every non-negative integer to a lower or equal non-negative integer (no perfect compression), but you can have functions that compress everything we care about at the cost of increasing the size of things we don't care about. So the recursive de-indexing strategy has to sometimes fail and increase the cost (once you account for storing the prefix).

It would average the same size as the actual data. Treating the pi bit sequence as random bits, and ignoring overlap effects, the probability that a given n bit sequence is the one you want is 1/2^n, so you need to try on average 2^n sequences to find the one you want, so the index to find it is typically of length n, up to some second order effects having to do with expectation of a log not being the log of an expectation.

Why go through all that effort, when it's just tau/2.

For those of us who were last paid to write C++ in a different millenium, suggestions for a book to catch up?

The way I've been telling it:

- It's statistics if the goal is to figure out why it works

- It's data science if nobody cares why it works

- It's ML if nobody knows why it works

- It's AI if it's actually impossible to figure out why it works

The definitions are not quite mutually exclusive.

Yes! Now, we just have to run this inside a browser, which will run inside a container, which will run inside a VM, which will run on an emulation layer...

Feels like one of those technologies where you read about it, and it seems cool/powerful and you wish you had a use case to try it out, but can never find one that you can't handle more easily without it. Am I missing some big current, real-world application?

Is there an out-of-the-box solution that just does all of this - as a hosted solution, a boilerplate, or a best-practices example? Maybe Supabase could do it? Would be nice to one-click deploy a Postgres with cache and auditing and the rest of it.

But temperature 0 LLM's don't exhibit the emergent phenomena we like, even in apparently non-creative tasks. The randomness is, in some sense, a cheap proxy for an infeasible search over all completion sequences, much like simulated annealing with zero temperature is a search for a local optimum but adding randomness makes it explore globally and find more interesting possibilities.

This seems like a good place to ask - if your knowledge of (computation/complexity) theory is at the level of the Sipser Introduction to the Theory of Computation book, what's a good learning path to get current?

What's the deal with hosted open source model services not supporting grammars? I've seen fireworks.ai do it, but not anybody else - am I missing something?

Ironically, .Net has several.

Hetzner GPU servers at $200/month for an RTX 4000 with 20GB seem competitive. Anyone have experience with what kind of token throughput you could get with that?

do you mean 1.28 TB?

The Clojure/JVM statistics/scientific computing/now tensor math packages just never got as good as Python, and in Smalltalk they were a non-starter. R is an awkward language, but it's repl-first, has a lot of Lisp's metaprogramming (done in very ad-hoc ways), and Smalltalk's serializable image model -- so a lot of exploratory/experimental statistical methods research happens there, and then gradually makes its way to Python when it needs to be stabilized for production.

F# based .Net would've made a fine math-centric environment, but it's a language with a high initial barrier, and though .Net community has been making a decent effort at porting over a lot of NumPy/SciPy, it's not fully caught up after many years.

We have Julia now, it's jitted, multicore/GPU friendly, and has interesting REPL innovations, and yes, serializable state (though, ugh, ligatures). But every time I reach for it, it's like, oh no, yet another thing I want to call is in the Python ecosystem. Especially all the modern deep learning/tensor stuff, where the assumption is Python's speed and the GIL don't matter because you're just gluing together GPU calls.

Notebooks are a diluted form of the Lisp/Smalltalk REPL-based development experience, with some features from the reactive-spreadsheet world. Especially for those of us in the business of producing numbers, 'real code' with a fixed set of tests isn't a better way but a necessary evil, a black box that we can't really trust. Building a calculation piece by piece, in a notebook, trying out variations along the way? That's how you get a feel for the calculation, connect with it at a spiritual level.

Would we even hate the ads so much if they so many of them weren't overtly scammy? Give us quality ads and have a working system for reporting scammy or otherwise inappropriate ads, and the resistance will be much lower. A premium option for people who value their time is an entirely legit business model; taking scammers' money and effectively encouraging them to prey on free users to push users toward becoming paid users - that's not cool.

As previously done by the rock group KMFDM.

Hooray for containerized models, but a game changing feature for such containers could be K-V/prefix caching.

Previous discussion: https://news.ycombinator.com/item?id=40034972#40036309

Is the best match dot product (or other distance metric used) below some level? What the good level is would have to be examined for your particular use case, maybe make a histogram of the best (or several best) dot products from many good searches and pick some quantile.

Clojure, ClojureScript, and LFE are all production-ready, primarily because they have straightforward integration with existing VM's/ecosystems (JVM, JS, and BEAM respectively).

Sadly the .Net Clojure seems to be unmaintained, and there aren't obvious leading choices for the LLVM or Python worlds (Hy exists, is usable and interoperable, but doesn't have a clear value prop, maybe macros). C world has Racket I suppose. WASM has an S-Expression representation, but that alone does not a lisp make.

Anyone who has spent enough time in AR to compare, how's the headache/eye fatigue compared with VR?

They promise free (domain) email hosting, that's kind of interesting... Anybody see a catch (other than, it's ByteDance?)

It's the centenary of Kafka's death today. Remember him by doing something absurd and horrifying.

At something like a cent per message, both ways, SMS is annoyingly expensive for any application with a lot of back and forth traffic - hence, chatbot-over-SMS solutions are rare, and auth providers charge extra for SMS based verifications. Does this create a niche opportunity for dumbphones where in-network SMS is cheaper to provide a light-llm-over-ssm service?