benpacker

The end result is almost the same as an audit table except there's much more work to do at read time, and some queries simply cannot scale as they need to with this approach.

In general for most apps you'd rather have 2 writes (write to table and write to audit table) than 1 write to the event log and hard to scale reads.

Yes - they are open weights and open inference code, which means they can be integrated into Ollama.

They are not “open training” (either in the training code or training data sense), so they are not reproducible, which some have suggested ought to be a component of the definition of open models.

Most of this is inaccurate.

The history of unions is long and complex. Although there has been tension historically between craft unionism and industrial unionism (the original term for lower skilled work), that was mostly in the pre-war period and not really related to the purpose of unions.

No one is forced into paying union dues now anymore than someone is forced to take any particular job. Workers negotiate a contract with their employer that includes a commitment to include all employees as part of the union. It's just a contract.

easier to scale to a distributed TPU cluster I think?

Is that lossy?

Isn't the vector representation of the text (and the ANN index itself) lossy, and the source text itself the source of truth?

Yep, that’s right. Modal (https://modal.com) is actually what you’re describing with Python, but Modal is just the compute layer (Unison is going for the whole cloud), and Modal isn’t doing anything to handle version alignment across service boundaries

I haven’t used the service or language, but I imagine if you’re familiar with it, the above snippet feels like Typscript does to me.

From their written materials, it looks like the thing you’re missing is that this is a single source of truth.

For most systems, I change my code, build and push a container, and then have to update the YAML to make sure it addresses the right container, and then push that. Obviously a lot of us have that all automated, but I don’t know anyone for whom that automation is easy and never needs to be escaped.

Again, I’m not a user of the platform, but as a user of what they are innovating on top of I can see what they are going for.

I definitely think trying to find similarity on a variable subset of dimensions is required. Fingers crossed I get the time to try soon

I like this, and I like Bun, and I’m going to use this, but I’m nervous about whether Bun’s ultimate share of the server-side cloud Javascript will be big enough to sustain the maintenance surface area they are carving out for themselves.

Hope they succeed though!

Ah wow, I'm not a frequent player so I didn't know how clever it can get!

I unfortunately can’t imagine having time to test this, but I imagine there may be a way to accomplish this with embeddings.

The game itself is sort of an embeddings clustering problem, with the added difficulty that each group needs to only be alike in 1 way (versus a full vector distance which measures how alike they are in every way).

Maybe there is some way to search for a vector of weights, which, when multiplied by all members of a group of 4, produces weighted vectors with the least distance from their center? And then it’s an optimization problem to find the 4 groups that find minimize the total distance from each groups center?

It may be possible to find a weight vector that selects for a particular slice of a words meaning

My understanding is that Cloud Run is not suitable for stateful workloads (databases, etc.)

If I use GKE or any other standard Kubernetes offering (excluding GKE autopilot for now), if I have a variable workload and I want Node-level autoscaling, I will probably pay between 1.5x-2.5x in compute costs above what my Pod requests sum to because of difficulty with Node utilization.

It seems like with FKS, my pods will map directly to Fly Machines billing, and so there’s no compute that I’m paying for but not using

If this is “free GKE autopilot” (autopilot billed at the same price as regular Fly Machine compute), then that changes the way I think about Fly’s basic compute pricing a lot.

I would think they should highlight that a lot more in the product announcement!

Typo haha - I meant GKE. Fixed now.

I think there’s a slight misunderstanding - I’m referring to how much of a Node is being used by the Pods running on it, not how much of each Pod’s compute is being used by the software inside it.

Even if my Pods were perfectly sized, a large percent of the VMs running the Pod was underutilized because the Pods were poorly distributed across the Nodes

Unfortunately last I checked the compute pricing for GKE autopilot was almost double, so if you can beat 50% utilization, you might as well just keep the under-utilized Node around.

Am I understanding correctly that because they map a “Pod” to a “Fly Machine”, there’s no intermediate “Node” concept?

If so, this is very attractive. When using GKS, we had to do a lot of work to get our Node utilization (the percent of resources we had reserve on a VM actually occupied by pods) to be higher than 50%.

Curios what happens when you run “kubectl get nodes” - does it lie to you, or call each region one Node?

If you’re just learning about this from outside the United States, some important context is that the domestic narrative about 9/11 was that “They hate us for our freedoms”.

Substantive discussion about Bin Laden’s motivations and his stated reasons for the attack were generally absent, and even the top line of the reasons themselves was not repeated on cable news.

It appears the majority of these young people are just discovering for the first time that there was some stated reason at all, that terrorism is political (and usually not driven by like a supra political cosmological hate).

I think it’s a useful and clarifying thing for people to learn, and the vast majority learning about this now don’t support 9/11, obviously.

Some highlights:

“In order to procure the necessary raw materials for knife production, one of us (M.I.E.) went on a diet with high protein and fatty acids, which is consistent with an arctic diet, for eight days…”

“Raw material collection did not begin until day four, and then proceeded regularly for the next five days (Table S1). Fecal samples were formed into knives using ceramic molds, “knife molds” (Figs. S1–S2), or molded by hand, “hand-shaped knives””

“We repeated the experiment using the fecal samples of another team member (M.R.B.), whose diet was more traditionally Western (see supplementary online materials)”

I know price will vary wildly based on how many you’re buying, but does anyone have the roughest ballpark for how much it would cost to buy one (1), or like two?

This is the docs repo

It implements the BEAM, so any language that shares the runtime can be made to work (Elixir, Gleam, etc)

This is quite confusing - you shouldn’t need a columnar engine to filter/aggregate 20k rows.

Postgres / MySQL with a table per board (or one giant partitioned table with a JSONb column) would have been totally fine, as would have one SQLite database per customer that you can load the initial page of and then ship the whole thing to the client for richer interactivity.

I’m not sure if Postgres could support that type of operation directly via count() since I don’t know if the fact that no other filters are present is available to the Index Access Method API.

It might be possible to do a separate function though, like:

select pg_bm25_direct_count(‘term’)*

The underlying engine, Tantivy, has better performance characteristics than Lucene.

You can compare Lucene to Tantivy and can compare Elasticsearch to pg_bm25 or ParadeDB

Kids learn grammar by copying, but a group of kids with no language will invent one (see Nicaraguan sign language), and empty transformer models will not do this.

Kids raised hearing a mix of French and African languages will also invent a new language (Haitian creole) and a LLM will not do this, it would alternate speaking one or the other.

ChatGPT proves that language is not so complex that it can’t be modeled, but the core Chomsky arguments are unaffected.

I haven’t looked into the alternative perspectives (emergent grammar, etc) in the discipline since undergrad so I’m not saying Chomsky is right, just saying LLMs don’t disprove it.

How does this compare to Parseable?

https://github.com/parseablehq/parseable

First guess is that the underlying storage / query layer is pretty similar (Parquet + Datafusion), but OpenObserve has more built in use cases?

As an aside, it’s awesome that Datafusion’s existence and maturity makes launching a product with scalable analytical reads 10x easier than before and cool to see so many projects integrating it

A bit odd that Pinecone is publishing this…

I can understand if they identified that building with LangChain means more Pinecone usage, and a barrier to building with Langchain is its documentation and ease of getting started, but if the now well funded project isn’t producing this itself (and in my own experience the Typescript library at least doesn’t feel like it’s hitting the nail on the head and I ended up reading source code) then I think that’s a sign we’re still searching for the best way to build complex things here

Mods help! This thread is getting positive bot spammed. All these accounts were created within the last half hour