2,861 karma · joined November 16, 2013
https://emmanueloga.com
https://lobste.rs/~emmanueloga
https://mastodon.gamedev.place/@EmmanuelOga
https://bsky.app/profile/emmanuel-oga.bsky.social
A simple workaround is serving HTTP through a single process language like Go or JavaScript, since Kuzu has bindings for both. Other processes could access the database directly in read-only mode for analysis [2].
For better DX, the ideal would be Kuzu implementing the Bolt protocol of Neo4J directly in the binary, handling single-writer and multi-reader coordination internally. Simpler alternative: port the code from [3] to C++ and add a `kuzu --server` option.
--
1: https://fastapi.tiangolo.com/deployment/server-workers/#mult...
2: https://docs.kuzudb.com/concurrency/#scenario-2-multiple-pro...
3: https://github.com/kuzudb/explorer/tree/master/src/server
An outline doesn't have to be a compressed version, I think more like a map of the content, which tells me what to expect as I make progress through the article. You might consider using a structure like SCQA [1] or similar.
--
1: https://analytic-storytelling.com/scqa-what-is-it-how-does-i...
One bit of hopefully constructive feedback: your previous post ran about 60 printed pages, this one's closer to 40 (just using that as a rough proxy for time-to-read). I’ve only skimmed both for now, but I found it hard to pin down the main purpose or takeaway. An abstract-style opening and a clear conclusion would go a long way, like in academic papers. I think that makes dense material way more digestible.
From a user perspective, having several tools that overlap heavily but differ in subtle ways makes evaluation and adoption harder. It feels like if any two of these projects consolidated, they’d have a good shot at becoming the "default" eBPF observability solution.
In JavaScript:
function toposort(graph = { a: ['b', 'c'], b: ['d'] }) {
const order = [];
const visited = new Map();
function dfs(node) {
const status = visited.get(node);
if (status === 1) throw new Error("Cycle found.");
if (status === 2) return;
visited.set(node, 1); // In progress.
const adjacent = graph[node] ?? [];
for (const neighbor of adjacent) dfs(neighbor);
visited.set(node, 2); // Done.
order.unshift(node); // Reverse post order.
}
for (const node in graph) {
if (!visited.has(node)) dfs(node);
}
return order;
}An improvement on [1], which I vaguely remember using with pen and paper to find minimums of differentiable functions. The original algorithm runs "on a loop" (iteratively) and utilizes the first and second order derivative of a function (f', f''). From the article:
> Newton did it for degree 2. He did that because nobody knew how to minimize higher-order polynomials
The improved version looks a lot more complex but seems to sacrifice simplicity to converge faster to the minimum when implemented as a program.
Trivia: a "single loop" of the Newthon method is famously used in Quake's Fast InvSqrt() implementation [2].
--
1: https://en.wikipedia.org/wiki/Newton's_method
2: https://en.wikipedia.org/wiki/Fast_inverse_square_root#Newto...
I never ask myself why we still use hashmaps or heaps or whatnot, so makes me wonder if this is really an article about why Cedar does not use something else? (LSM-trees the elephant in the room?)
I used to work on a set top box app, and for some of the features, replacing the whole page with a single canvas was the only way to get steady FPS.
--
1: https://web.dev/articles/simplify-paint-complexity-and-reduc...
I found myself putting my finger directly into the paddle many times. Instead of the message "Push here to play" you could create a more obvious UI element where one should press (something like the grip part of a slider). Maybe even make the grip glow when you push it for funs :-).
In terms of the problem itself, a binary tree can be expressed something like:
type Node<T> = { value: T, left?: Node<T>, right?: Node<T> }
Given a root, you can invert it recursively with some code like this: function invertTree(root) {
if (!root) return null;
// Swap!
const tmp = root.left;
root.left = invertTree(root.right);
root.right = invertTree(tmp);
return root;
};
Or using an explicit stack: function invertTree(root) {
const stack = [root];
while (stack.length > 0) {
const node = stack.pop(); if (!node) continue;
// Swap!
const tmp = node.right;
node.right = node.left;
node.left = tmp;
stack.push(node.left);
stack.push(node.right);
}
return root;
}
I think without prep would be harder to come up with the non-recursive version.> The finding that language models can get better by generating longer outputs directly contradicts Yann’s hypothesis.
The author's examples show that the error has been minimized for a few examples of a certain length. This doesn't contradict Lecun, afaict.
The main objective seems to be advocacy/evangelism on new browser animation APIs, which I welcome [1].
... I agree that the top mouse animation is, errr... a bit ugly, though :-).
--
Also replacing some of CF primitives with something else later can be viable, specially if you plan for it.
Regarding spaced repetition, RemNote 1.17 an 1.18 has a bunch of AI features for summarizing PDFs and YouTube transcripts and turning that into Q&A for spaced repetition, and they also have a Chatbot interface in-app. Perhaps you could check some of what they are doing for inspiration [4].
--
1: https://developers.cloudflare.com/workers/languages/
function sum(f: (x: number) => number, upper = 500) {
let sum = 0;
for (let n = 0; n < upper; n++) sum += f(n);
return sum;
}
const weierstrass = (x: number, a = 0.5, b = 3) =>
sum(n => a ** n * Math.cos(b ** n * x));I worked on the "misstep" with a small team, and it’s wild to see Fiber still around and even expanding to new cities. As far as I can tell, the set-top box software had nothing to do with why Fiber was scaled down. Also, usability surveys showed people really liked the GUI!
The client supported on-demand streaming, live TV, and DVR on hardware with... let’s call them challenging specs. Still, it turned out to be a pretty slick app. We worked hard to keep the UI snappy (min 30 FPS), often ditching DOM for canvas or WebGL to squeeze out the needed performance. A migration to Cobalt [1], a much lighter browser than embedded Chromium, was on the table, but the project ended before that could happen.
Personally, it was a great experience working with the Web Platform (always a solid bet) on less-traditional hardware.
--
The point about lack of tooling for Babylon.JS is interesting: a lot of times I see people wanting to release games but spending most of the time building tools... sometimes all of the time. It is a delicate balance!
Congratulations on releasing! Very cool project.
--
* Have graphviz or some other solver output the [x;y] pairs for each vertex.
* Use the initial positions to create, with a physics engine, a construct where vertices are masses connected by springs following the DAG.
* Add a resizable bounding box constraint around the whole thing.
* Push and pull the boundaries and masses until you get something nice.
What you say still applies: you may want to give the user the ability to resize the masses and re-run the layout algorithm, etc.
Yes, you can drive a Ford Falcon coast-to-coast, but how much gas are you going to spend? Postgres is a solid database but has roots in the 80s. Optimizing for modern hardware would reduce hosting costs and improve efficiency. [3]
This isn’t criticism of Postgres as a database but of the idea that it’s inherently sufficient for all use cases.
--
1: https://www.cs.cmu.edu/~pavlo/blog/2025/01/2024-databases-re...
2: https://blog.kuzudb.com/post/what-every-gdbms-should-do-and-...
3: https://cedardb.com/blog/ode_to_postgres/#why-is-everyone-st...
* "We're adding timeouts to prevent user requests from waiting excessively long to retrieve assets."
When you get to the size of Canva, you can't forget your AbortController and exponential backoff on your Fetch API calls.
--
0: https://www.canva.dev/blog/engineering/canva-incident-report...