BenoitP

> He's still computing cross(z, d) and dot(z, d) separately. that looks like a code smell to me. with quaternions ...

Fair point, but I think you misspelled Projective Geometric Algebra

But the newer commenters most probably could be younger

> laser pulses

> phased-array

I'm not well versed into RF physics. I had the feeling that light-wave coherency in lasers had to be created at a single source (or amplified as it passes by). That's the first time I hear about phased-array lasers.

Can someone knowledgeable chime in on this?

A hard problem, especially wrt to transactions on a moving target.

From memory, handful of projects just dedicated to this dimension of databases: Noria, Materialize, Apache Flink, GCP's Continuous Queries, Apache Spark Streaming Tables, Delta Tables, ClickHouse streaming tables, TimescaleDB, ksqlDB, StreamSQL; and dozens more probably. IIRC, since this is about postgres, there is recently created extension trying to deal with this: pg_ivm

On the brand new and shiny 486 running dos and windows 3.1 that my father bought, on the qbasic language. With only a paper book as reference. No llm, no stackoverflow, no pageranked search engine, no internet, and not even Ctrl+F. In these days when you had a bug, you could chew on it for days.

Of note is that once you've got planes, you can define points as intersections of n hyperplanes.

In 2D, 2 intersecting hyperplanes (=lines here) will define a point.

But what if these lines are parallel? Well you just got the "point at infinity" abstraction for free. And if you defined operators on points as intersections of lines they will also work with the points at infinity.

All this being nicely described under Projective Geometric Algebra: https://projectivegeometricalgebra.org/projgeomalg.pdf

Also: with a few modifications you get conformal geometry as well; with everything being defined as intersections of spheres. After all, what is a plane but a sphere that has its center at infinity?

Most programs should be written in GCd languages, but not this.

Except in a few cases, GCs introduce small stop-the-world pauses. Even at 15ms pauses, it'd still be very noticeable.

> > Just intuitively, in such a high dimensional space, two random vectors are basically orthogonal.

> What's the intuition here? Law of large numbers?

Yep, the large number being the number of dimensions.

As you add another dimension to a random point on a unit sphere, you create another new way for this point to be far away from a starting neighbor. Increase the dimensions a lot and then all random neighbors are on the equator from the starting neighbor. The equator being a 'hyperplane' (just like a 2D plane in 3D) of dimension n-1, the normal of which is the starting neighbor, intersected with the unit sphere (thus becoming a n-2 dimensional 'variety', or shape, embedded in the original n dimensional space; like the earth's equator is 1 dimensional object).

The mathematical name for this is 'concentration of measure' [1]

It feels weird to think about it, but there's also a unit change in here. Paris is about 1/8 of the circle far away from the north pole (8 such angle segments of freedom). On a circle. But if that's the definition of location of Paris, on the 3D earth there would be an infinity of Paris. There is only one though. Now if we take into account longitude, we have Montreal, Vancouver, Tokyo, etc ; each 1/8 away (and now we have 64 solid angle segments of freedom)

[1] https://www.johndcook.com/blog/2017/07/13/concentration_of_m...

> "theory building"

Strongly agree with your comment. I wonder now if this "theory building" can have a grammar, and be expressed in code; be versioned, etc. Sort of like a 5th-generation language (the 4th-generation being the SQL-likes where you let the execution plan be chosen by the runtime).

The closest I can think of:

* UML

* Functional analysis (ie structured text about various stakeholders)

* Database schemas

* Diagrams

A bit late to the discussion, but this has deep connections. As a programmer, your job is provide business invariants using complexity management techniques. And checking that your state space is small is a tool with gigantic payoff.

Maintaining a small state space it why we want to let it crash. Each program instruction can potentially multiply the number of states possible. Erlang even has this whole "Let It Crash" philosophy as a guideline [1].

Maintaining a small state space is how you tame concurrent programs, where adding one thread can cartesian-product your state space. But there are tools like TLA+ which can help you build proofs over this state space. And build invariants that your threads can use safely. Hre is a visualizer of that state space [2]. Notice any resemblance to the graphs you just saw in the video?

Programming sometimes feel like this "Rush Hour" puzzle.

[1] https://wiki.c2.com/?LetItCrash [2] https://prob.hhu.de/w/index.php?title=State_space_visualizat...

I'm failing to grasp how it solves/replaces what vector db were created for in the first place (high-dimensional neighborhood searching, where the space to be searched grows by distance^dimension)

Now testify!

You mean Nouvelle Nouvelle France ?

* with shareholder money

Tabular data is everywhere in the corporate world. I feel like there is a zillion opportunities to make money with these transformers. But how to enter that market remains a mystery to me.

Brute force it. Gemm routines can give you a best dot product among 300k vectors well under a second

LCOE is good for marginal analysis, but quite bad for a systemic and holistic view

Merit order is a hidden subsidy. Other means of producing electricity that have a theoretically lower marginal cost will need to curb their production.

*quasi-particle

> if I wanted a procedually generated world that just exist for no reason in particular, I'd walk outside..

Oops, old.reddit.com/r/outside/ is leaking again

I thought this was about texture mapping.

> Decomposition of causality: It decomposes causal interactions into redundant, unique, and synergistic contributions.

Seen elsewhere: https://github.com/BCG-X-Official/facet, which uses SHAP attributions as inputs:

> The SHAP implementation is used to estimate the shapley vectors which FACET then decomposes into synergy, redundancy, and independence vectors.

But FACET it still about sorting things out in the 'correlation world'.

To get back to SURD: IMHO, when talking about causality one should incorporate some kind of precedence, or order; One thing is the cause of another. Here in SURD they sort of introduce it in a roundabout way by using time's order:

> requiring only pairs of past and future events for analysis

But maybe we could have had fully-fledged custom DAGs, like from here https://github.com/nathanwang000/Shapley-Flow (which don't yet have the redundant/unique/synergistic decomposition)

Also, how do we deal with undetectable "post hoc ergo propter hoc" fallacy, though? (travesting time as causal ordering). How do we deal with confounding? Custom DAGs would have been great.

I'm longing for a SURD/SHAP/FACET/Shapleyflow integration paper. We're so close to it.

And thus custom validation goes to json, completing a what is old is new again cycle. After XML/XSD, after CORBA.

TL;DR: you need energy if you want to build/transform/produce/transport things

The 'introduction' from what is now v1, a 15mn read:

https://scp-wiki.wikidot.com/we-need-to-talk-about-fifty-fiv...

What would be nice with that would be an additional explanation as to their popularity.

Why not binary trees? Because random memory fetch can incur high latency. How to size max node size? -> Aim for L1 or cache line size; Just like like we make ring buffers fit into L2/L3.

1 > 0. And most of the cost comes from maintaining engineer's salaries on a single project.

If new projects get ordered I'm quite confident costs will move closer to the actual bill of materials, per unit.

Or Go. Or Java' virtual threads.

It must happen at the language level; When it comes to execution context knowledge: what context to compile out (stackless), or what context to serialize to the heap (stackful). Programming language will always know much more about the program than the OS.

If I'm not mistaken in Erlang the programmer will provide the exact context to serialize : the actor.

Thanks for putting words into this.

Another cut off could be 3 cm away: the RAM. If data needs to go on the heap, be shared, one can consider the truth lives farther away than 3cm and thus has async/impure effects.

> Now imagine a parallel universe where instead of focusing on making asynchronous IO work

Funny choice of words. In the JVM world, Ron Pressler's first foray into fibers -quasar- was named "parallel universe". It worked with a java agent manipulating bytecode. Then Ron went to Oracle and now we have Loom, aka a virtual thread unmounted at each async IO request.

Java's Loom is not even mentioned in the article. I wonder for a cofounder: does the "parallel universe" appear in a other foundational paper, calling for a lightweight thread abstraction?

https://docs.paralleluniverse.co/quasar/

Anyway, yes we need sound abstractions for async IO